def create_owned_page(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {
'page_id': 'int',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/owned_pages',
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_pending_owned_ad_accounts(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.adobjects.legacybusinessadaccountrequest import LegacyBusinessAdAccountRequest
param_types = {}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/pending_owned_ad_accounts',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=LegacyBusinessAdAccountRequest,
api_type='EDGE',
response_parser=ObjectParser(
target_class=LegacyBusinessAdAccountRequest, 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_v2.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 create_offline_conversion_data_set(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.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 create_event_source_group(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.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 get_grp_plans(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.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(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {
'data': 'list<Object>',
'namespace_id': 'string',
'progress': 'Object',
'upload_id': 'string',
'upload_tag': 'string',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/events',
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_lead_gen_forms(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.adobjects.leadgenform import LeadgenForm
param_types = {
'page_id': 'string',
'query': 'string',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/leadgen_forms',
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 get_ads(self, fields=None, params=None, batch=None, pending=False):
from facebookads_v2.adobjects.ad import Ad
param_types = {
'ad_draft_id': 'string',
'date_preset': 'date_preset_enum',
'effective_status': 'list<string>',
'include_deleted': 'bool',
'time_range': 'Object',
'updated_since': 'int',
}
enums = {
'date_preset_enum': Ad.DatePreset.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/ads',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Ad,
api_type='EDGE',
response_parser=ObjectParser(target_class=Ad, 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_copies(self, fields=None, params=None, batch=None, pending=False):
param_types = {
'date_preset': 'date_preset_enum',
'effective_status': 'list<effective_status_enum>',
'is_completed': 'bool',
'time_range': 'Object',
}
enums = {
'date_preset_enum': Campaign.DatePreset.__dict__.values(),
'effective_status_enum':
Campaign.EffectiveStatus.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/copies',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Campaign,
api_type='EDGE',
response_parser=ObjectParser(target_class=Campaign, 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_label(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.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, 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_promotable_events(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.adobjects.event import Event
param_types = {
'include_past_events': 'bool',
'is_page_event': 'bool',
'page_id': 'unsigned int',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/promotable_events',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Event,
api_type='EDGE',
response_parser=ObjectParser(target_class=Event, 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_promotable_domains(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.adobjects.domain import Domain
param_types = {}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/promotable_domains',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Domain,
api_type='EDGE',
response_parser=ObjectParser(target_class=Domain, 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_picture(self, fields=None, params=None, batch=None, pending=False):
from facebookads_v2.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,
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_ads_pixel(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.adobjects.adspixel import AdsPixel
param_types = {
'name': 'string',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/adspixels',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdsPixel,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdsPixel, 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_shared_audience_permissions(self,
fields=None,
params=None,
batch=None,
pending=False):
param_types = {
'partner_id': 'string',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/shared_audience_permissions',
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_accounts(self,
fields=None,
params=None,
batch=None,
pending=False):
from facebookads_v2.adobjects.page import Page
param_types = {
'business_id': 'string',
'is_business': 'bool',
'is_place': 'bool',
'is_promotable': 'bool',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/accounts',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Page,
api_type='EDGE',
response_parser=ObjectParser(target_class=Page, 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()
