def api_update(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
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='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=OfflineConversionDataSet,
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_ad_account(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'adaccounts': 'list<string>',
'permissions': 'string',
'relationship_type': 'list<string>',
'replace': 'bool',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/adaccounts',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=CustomAudience,
api_type='EDGE',
response_parser=ObjectParser(target_class=CustomAudience, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_agency(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'business': 'string',
'other_relationship': 'string',
'permitted_roles': 'list<permitted_roles_enum>',
'relationship_type': 'list<relationship_type_enum>',
}
enums = {
'permitted_roles_enum': OfflineConversionDataSet.PermittedRoles.__dict__.values(),
'relationship_type_enum': OfflineConversionDataSet.RelationshipType.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/agencies',
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_photo(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'ad_account': 'string',
'ad_image_hashes': 'list<string>',
'file': 'file',
'image_crops': 'list<map>',
'photos': 'list<string>',
'urls': 'list<string>',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/photos',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=NativeOfferView,
api_type='EDGE',
response_parser=ObjectParser(target_class=NativeOfferView, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_like(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'feedback_source': 'string',
'nectar_module': 'string',
'tracking': 'string',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/likes',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Post,
api_type='EDGE',
response_parser=ObjectParser(target_class=Post, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_event(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'data': 'list<string>',
'namespace_id': 'string',
'progress': 'Object',
'upload_id': 'string',
'upload_source': '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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_message_template(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'category': 'category_enum',
'components': 'list<map>',
'language': 'string',
'name': 'string',
}
enums = {
'category_enum': WhatsAppBusinessAccount.Category.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/message_templates',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=WhatsAppBusinessAccount,
api_type='EDGE',
response_parser=ObjectParser(target_class=WhatsAppBusinessAccount, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_update(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'action': 'action_enum',
'close_after_voting': 'bool',
'default_open': 'bool',
'show_gradient': 'bool',
'show_results': 'bool',
}
enums = {
'action_enum': VideoPoll.Action.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=VideoPoll,
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_reactions(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.profile import Profile
param_types = {
'type': 'type_enum',
}
enums = {
'type_enum': Profile.Type.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/reactions',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Profile,
api_type='EDGE',
response_parser=ObjectParser(target_class=Profile, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_delivery_estimate(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.adcampaigndeliveryestimate import AdCampaignDeliveryEstimate
param_types = {
'optimization_goal': 'optimization_goal_enum',
'promoted_object': 'Object',
'targeting_spec': 'Targeting',
}
enums = {
'optimization_goal_enum': AdCampaignDeliveryEstimate.OptimizationGoal.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/delivery_estimate',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdCampaignDeliveryEstimate,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdCampaignDeliveryEstimate, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_pricing_variables(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.dynamicpriceconfigbydate import DynamicPriceConfigByDate
param_types = {
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/pricing_variables',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=DynamicPriceConfigByDate,
api_type='EDGE',
response_parser=ObjectParser(target_class=DynamicPriceConfigByDate, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_update(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'evaluation_spec': 'Object',
'execution_spec': 'Object',
'name': 'string',
'schedule_spec': 'Object',
'status': 'status_enum',
}
enums = {
'status_enum': AdRule.Status.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdRule,
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_ad_rules_governed(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.adrule import AdRule
param_types = {
'pass_evaluation': 'bool',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/adrules_governed',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdRule,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdRule, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_copies(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'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='/copies',
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_user_permissions(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'user': '******',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/userpermissions',
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_shared_account_info(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.customaudiencesharedaccountinfo import CustomAudiencesharedAccountInfo
param_types = {
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/shared_account_info',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=CustomAudiencesharedAccountInfo,
api_type='EDGE',
response_parser=ObjectParser(target_class=CustomAudiencesharedAccountInfo, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_home_listings(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.homelisting import HomeListing
param_types = {
'bulk_pagination': 'bool',
'filter': 'Object',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/home_listings',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=HomeListing,
api_type='EDGE',
response_parser=ObjectParser(target_class=HomeListing, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_user_permission(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'tasks': 'list<tasks_enum>',
'user': '******',
}
enums = {
'tasks_enum': EventSourceGroup.Tasks.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/userpermissions',
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_custom_audience(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'account_id': 'string',
'audience_name': 'string',
'audience_type': 'audience_type_enum',
'cell_id': 'string',
'objective_id': 'string',
}
enums = {
'audience_type_enum': AdStudy.AudienceType.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/customaudiences',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdStudy,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdStudy, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_test_lead(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.lead import Lead
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=Lead,
api_type='EDGE',
response_parser=ObjectParser(target_class=Lead, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_insights(self, fields=None, params=None, is_async=False, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.insightsresult import InsightsResult
if is_async:
return self.get_insights_async(fields, params, batch, success, failure, pending)
param_types = {
'metric': 'list<metric_enum>',
}
enums = {
'metric_enum': InsightsResult.Metric.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/insights',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=InsightsResult,
api_type='EDGE',
response_parser=ObjectParser(target_class=InsightsResult, api=self._api),
include_summary=False,
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
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, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
from facebook_business.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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_copy(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'adset_id': 'string',
'rename_options': 'Object',
'status_option': 'status_option_enum',
}
enums = {
'status_option_enum': Ad.StatusOption.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/copies',
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_history(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.adrulehistory import AdRuleHistory
param_types = {
'action': 'action_enum',
'hide_no_changes': 'bool',
'object_id': 'string',
}
enums = {
'action_enum': AdRuleHistory.Action.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/history',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdRuleHistory,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdRuleHistory, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_update(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'composed_text': 'list<map>',
'cover_photo': 'map',
'entity_map': 'list<map>',
'is_published': 'bool',
'title': 'string',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=PageAboutStory,
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_get(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=PageAdminNote,
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_errors(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.productfeeduploaderror import ProductFeedUploadError
param_types = {
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/errors',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductFeedUploadError,
api_type='EDGE',
response_parser=ObjectParser(target_class=ProductFeedUploadError, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_update(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'metadata': 'list',
'title': 'string',
'universal_content_id': 'string',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=MediaFingerprint,
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_insights(self, fields=None, params=None, is_async=False, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.adsinsights import AdsInsights
if is_async:
return self.get_insights_async(fields, params, batch, success, failure, pending)
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<string>',
'filtering': 'list<Object>',
'level': 'level_enum',
'product_id_limit': 'int',
'sort': 'list<string>',
'summary': 'list<string>',
'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(),
'level_enum': AdsInsights.Level.__dict__.values(),
'summary_action_breakdowns_enum': AdsInsights.SummaryActionBreakdowns.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/insights',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdsInsights,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdsInsights, api=self._api),
include_summary=False,
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def delete_ad_labels(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'adlabels': 'list<Object>',
'execution_options': 'list<execution_options_enum>',
}
enums = {
'execution_options_enum': AdSet.ExecutionOptions.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='DELETE',
endpoint='/adlabels',
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_shared_account_info(self,
fields=None,
params=None,
batch=None,
success=None,
failure=None,
pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning(
'`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.customaudiencesharedaccountinfo import CustomAudiencesharedAccountInfo
param_types = {}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/shared_account_info',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=CustomAudiencesharedAccountInfo,
api_type='EDGE',
response_parser=ObjectParser(
target_class=CustomAudiencesharedAccountInfo, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_upload(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.productfeedupload import ProductFeedUpload
param_types = {
'fbe_external_business_id': 'string',
'file': 'file',
'password': '******',
'update_only': 'bool',
'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, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_admin(self,
fields=None,
params=None,
batch=None,
success=None,
failure=None,
pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning(
'`success` and `failure` callback only work for batch call.')
param_types = {
'uid': 'int',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/admins',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Group,
api_type='EDGE',
response_parser=ObjectParser(target_class=Group, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_rules(self,
fields=None,
params=None,
batch=None,
success=None,
failure=None,
pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning(
'`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.productfeedrule import ProductFeedRule
param_types = {}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/rules',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductFeedRule,
api_type='EDGE',
response_parser=ObjectParser(target_class=ProductFeedRule,
api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_contained_offline_conversion_data_sets(self,
fields=None,
params=None,
batch=None,
success=None,
failure=None,
pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning(
'`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.offlineconversiondataset import OfflineConversionDataSet
param_types = {}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/contained_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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_stats(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.adspixelstatsresult import AdsPixelStatsResult
param_types = {
'aggregation': 'aggregation_enum',
'end_time': 'datetime',
'event': 'string',
'event_source': 'string',
'start_time': 'datetime',
}
enums = {
'aggregation_enum': AdsPixelStatsResult.Aggregation.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/stats',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdsPixelStatsResult,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdsPixelStatsResult, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_update(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'currency': 'string',
'description': 'string',
'destination_airport': 'string',
'images': 'list<Object>',
'origin_airport': 'string',
'price': 'unsigned int',
'url': 'string',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Flight,
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_get(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'icon_size': 'icon_size_enum',
}
enums = {
'icon_size_enum': [
'16',
'34',
'50',
'68',
],
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Group,
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_ad_sets(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.adset import AdSet
param_types = {
'date_preset': 'date_preset_enum',
'effective_status': 'list<effective_status_enum>',
'is_completed': 'bool',
'time_range': 'Object',
}
enums = {
'date_preset_enum': AdSet.DatePreset.__dict__.values(),
'effective_status_enum': AdSet.EffectiveStatus.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/adsets',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdSet,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdSet, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_update(self,
fields=None,
params=None,
batch=None,
success=None,
failure=None,
pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning(
'`success` and `failure` callback only work for batch call.')
param_types = {
'name': 'string',
}
enums = {}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=DynamicItemDisplayBundleFolder,
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_media(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.igmedia import IGMedia
param_types = {
'caption': 'string',
'children': 'list<unsigned int>',
'image_url': 'string',
'location_id': 'string',
'media_type': 'string',
'user_tags': 'list<map>',
}
enums = {
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/media',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=IGMedia,
api_type='EDGE',
response_parser=ObjectParser(target_class=IGMedia, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def add_field(self, field):
if field not in self._fields:
self._fields.append(field)
if field not in self._accepted_fields:
api_utils.warning(self._endpoint + ' does not allow field ' + field)
return self
def create_telemetry(self,
fields=None,
params=None,
batch=None,
success=None,
failure=None,
pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning(
'`success` and `failure` callback only work for batch call.')
param_types = {
'bitrate': 'unsigned int',
'broadcast_id': 'string',
'cpu_load_15m': 'float',
'cpu_load_1m': 'float',
'cpu_load_5m': 'float',
'cpu_temperature': 'unsigned int',
'cpu_usage': 'float',
'framerate': 'float',
'frames_dropped': 'float',
'gpu_temperature': 'unsigned int',
'gpu_usage': 'float',
'last_audio_timecode': 'unsigned int',
'last_video_keyframe_timecode': 'unsigned int',
'last_video_timecode': 'unsigned int',
'memory_usage': 'float',
'network_latency': 'float',
'network_rx_bandwidth': 'unsigned int',
'network_rx_packets_dropped': 'float',
'network_rx_packets_errors': 'float',
'network_tx_bandwidth': 'unsigned int',
'network_tx_packets_dropped': 'float',
'network_tx_packets_errors': 'float',
'process_uptime': 'unsigned int',
'status': 'status_enum',
'timestamp': 'unsigned int',
'total_audio_frames_sent': 'unsigned int',
'total_video_frames_sent': 'unsigned int',
'total_video_keyframes_sent': 'unsigned int',
'uptime': 'unsigned int',
}
enums = {
'status_enum': LiveEncoder.Status.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/telemetry',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=LiveEncoder,
api_type='EDGE',
response_parser=ObjectParser(target_class=LiveEncoder,
api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_update(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'content_tags': 'list<string>',
'privacy': 'Object',
'title': 'string',
'description': 'string',
'embeddable': 'bool',
'disturbing': 'bool',
'place': 'Object',
'published': 'bool',
'status': 'status_enum',
'end_live_video': 'bool',
'targeting': 'Object',
'tags': 'list<int>',
'og_phrase': 'string',
'og_icon_id': 'string',
'sponsor_id': 'string',
'direct_share_status': 'unsigned int',
'sponsor_relationship': 'unsigned int',
'planned_start_time': 'int',
'stream_type': 'stream_type_enum',
'attribution_app_id': 'string',
'attribution_app_metadata': 'string',
'custom_labels': 'list<string>',
'commercial_break_durations': 'list<unsigned int>',
'is_audio_only': 'bool',
'is_manual_mode': 'bool',
'schedule_custom_profile_image': 'file',
'schedule_feed_background_image': 'file',
'product_items': 'list<string>',
'ad_break_intent': 'bool',
'ad_break_start_now': 'bool',
'ad_break_drop_live_stream': 'bool',
'ad_break_time_offset': 'float',
'ad_break_encoder_drops_live_stream': 'bool',
'ad_break_duration': 'unsigned int',
'live_encoders': 'list<string>',
'live_comment_moderation_setting': 'list<live_comment_moderation_setting_enum>',
'crossposting_actions': 'list<map>',
'allow_bm_crossposting': 'bool',
}
enums = {
'status_enum': LiveVideo.Status.__dict__.values(),
'stream_type_enum': LiveVideo.StreamType.__dict__.values(),
'live_comment_moderation_setting_enum': LiveVideo.LiveCommentModerationSetting.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=LiveVideo,
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_update(self,
fields=None,
params=None,
batch=None,
success=None,
failure=None,
pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning(
'`success` and `failure` callback only work for batch call.')
param_types = {
'adlabels': 'list<Object>',
'adset_bid_amounts': 'map',
'adset_budgets': 'list<map>',
'bid_strategy': 'bid_strategy_enum',
'budget_rebalance_flag': 'bool',
'daily_budget': 'unsigned int',
'execution_options': 'list<execution_options_enum>',
'iterative_split_test_configs': 'list<Object>',
'lifetime_budget': 'unsigned int',
'name': 'string',
'objective': 'objective_enum',
'pacing_type': 'list<string>',
'promoted_object': 'Object',
'special_ad_category': 'special_ad_category_enum',
'spend_cap': 'unsigned int',
'status': 'status_enum',
'upstream_events': 'map',
}
enums = {
'bid_strategy_enum':
Campaign.BidStrategy.__dict__.values(),
'execution_options_enum':
Campaign.ExecutionOptions.__dict__.values(),
'objective_enum':
Campaign.Objective.__dict__.values(),
'special_ad_category_enum':
Campaign.SpecialAdCategory.__dict__.values(),
'status_enum':
Campaign.Status.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Campaign,
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_datum(self,
fields=None,
params=None,
batch=None,
success=None,
failure=None,
pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning(
'`success` and `failure` callback only work for batch call.')
param_types = {
'action_type': 'action_type_enum',
'batch_seq': 'unsigned int',
'encoding': 'encoding_enum',
'entries': 'list<string>',
'entry_type': 'entry_type_enum',
'last_batch_flag': 'bool',
'session_id': 'unsigned int',
}
enums = {
'action_type_enum': [
'add',
'match',
'optout',
'remove',
],
'encoding_enum': [
'md5',
'plain',
'sha256',
],
'entry_type_enum': [
'0',
'1',
'2',
'3',
'4',
'5',
'6',
],
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/data',
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_update(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'additional_image_urls': 'list<string>',
'additional_variant_attributes': 'map',
'android_app_name': 'string',
'android_class': 'string',
'android_package': 'string',
'android_url': 'string',
'availability': 'availability_enum',
'brand': 'string',
'category': 'string',
'checkout_url': 'string',
'color': 'string',
'condition': 'condition_enum',
'currency': 'string',
'custom_data': 'map',
'custom_label_0': 'string',
'custom_label_1': 'string',
'custom_label_2': 'string',
'custom_label_3': 'string',
'custom_label_4': 'string',
'description': 'string',
'expiration_date': 'string',
'gender': 'gender_enum',
'gtin': 'string',
'image_url': 'string',
'inventory': 'unsigned int',
'ios_app_name': 'string',
'ios_app_store_id': 'unsigned int',
'ios_url': 'string',
'ipad_app_name': 'string',
'ipad_app_store_id': 'unsigned int',
'ipad_url': 'string',
'iphone_app_name': 'string',
'iphone_app_store_id': 'unsigned int',
'iphone_url': 'string',
'manufacturer_part_number': 'string',
'material': 'string',
'mobile_link': 'string',
'name': 'string',
'offer_price_amount': 'unsigned int',
'offer_price_end_date': 'datetime',
'offer_price_start_date': 'datetime',
'ordering_index': 'unsigned int',
'pattern': 'string',
'price': 'unsigned int',
'product_type': 'string',
'retailer_id': 'string',
'sale_price': 'unsigned int',
'sale_price_end_date': 'datetime',
'sale_price_start_date': 'datetime',
'short_description': 'string',
'size': 'string',
'start_date': 'string',
'url': 'string',
'visibility': 'visibility_enum',
'windows_phone_app_id': 'string',
'windows_phone_app_name': 'string',
'windows_phone_url': 'string',
}
enums = {
'availability_enum': ProductItem.Availability.__dict__.values(),
'condition_enum': ProductItem.Condition.__dict__.values(),
'gender_enum': ProductItem.Gender.__dict__.values(),
'visibility_enum': ProductItem.Visibility.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=ProductItem,
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_conversion_paths(self,
fields=None,
params=None,
batch=None,
success=None,
failure=None,
pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning(
'`success` and `failure` callback only work for batch call.')
param_types = {
'click_lookback_window': 'unsigned int',
'date_range': 'map',
'fb_conversion_event_id': 'unsigned int',
'limit': 'unsigned int',
'metric_context': 'map',
'time_period': 'time_period_enum',
'view_lookback_window': 'unsigned int',
}
enums = {
'time_period_enum': [
'all_available',
'all_dates',
'custom',
'date_range',
'fifteen_days',
'last_fourteen_days',
'last_hundred_fourty_four_hours',
'last_month',
'last_ninety_days',
'last_quarter',
'last_seven_days',
'last_sixty_days',
'last_thirty_days',
'last_twenty_four_hours',
'last_year',
'month_to_date',
'quarter_to_date',
'seven_days',
'thirty_days',
'this_month_whole_days',
'today',
'week_to_date',
'year_to_date',
'yesterday',
],
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/conversion_paths',
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_update(self,
fields=None,
params=None,
batch=None,
success=None,
failure=None,
pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning(
'`success` and `failure` callback only work for batch call.')
param_types = {
'address': 'map',
'applinks': 'Object',
'availability': 'availability_enum',
'body_style': 'body_style_enum',
'condition': 'condition_enum',
'currency': 'string',
'date_first_on_lot': 'string',
'dealer_id': 'string',
'dealer_name': 'string',
'dealer_phone': 'string',
'description': 'string',
'drivetrain': 'drivetrain_enum',
'exterior_color': 'string',
'fb_page_id': 'string',
'fuel_type': 'fuel_type_enum',
'images': 'list<Object>',
'interior_color': 'string',
'make': 'string',
'mileage': 'map',
'model': 'string',
'price': 'unsigned int',
'state_of_vehicle': 'state_of_vehicle_enum',
'title': 'string',
'transmission': 'transmission_enum',
'trim': 'string',
'url': 'string',
'vehicle_type': 'vehicle_type_enum',
'vin': 'string',
'year': 'unsigned int',
}
enums = {
'availability_enum': Vehicle.Availability.__dict__.values(),
'body_style_enum': Vehicle.BodyStyle.__dict__.values(),
'condition_enum': Vehicle.Condition.__dict__.values(),
'drivetrain_enum': Vehicle.Drivetrain.__dict__.values(),
'fuel_type_enum': Vehicle.FuelType.__dict__.values(),
'state_of_vehicle_enum': Vehicle.StateOfVehicle.__dict__.values(),
'transmission_enum': Vehicle.Transmission.__dict__.values(),
'vehicle_type_enum': Vehicle.VehicleType.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Vehicle,
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_photo(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.photo import Photo
param_types = {
'aid': 'string',
'allow_spherical_photo': 'bool',
'alt_text_custom': 'string',
'android_key_hash': 'string',
'application_id': 'string',
'attempt': 'unsigned int',
'audience_exp': 'bool',
'backdated_time': 'datetime',
'backdated_time_granularity': 'backdated_time_granularity_enum',
'caption': 'string',
'composer_session_id': 'string',
'direct_share_status': 'unsigned int',
'feed_targeting': 'Object',
'filter_type': 'unsigned int',
'full_res_is_coming_later': 'bool',
'initial_view_heading_override_degrees': 'unsigned int',
'initial_view_pitch_override_degrees': 'unsigned int',
'initial_view_vertical_fov_override_degrees': 'unsigned int',
'ios_bundle_id': 'string',
'is_explicit_location': 'bool',
'is_explicit_place': 'bool',
'is_visual_search': 'bool',
'manual_privacy': 'bool',
'message': 'string',
'name': 'string',
'no_story': 'bool',
'offline_id': 'unsigned int',
'og_action_type_id': 'string',
'og_icon_id': 'string',
'og_object_id': 'string',
'og_phrase': 'string',
'og_set_profile_badge': 'bool',
'og_suggestion_mechanism': 'string',
'place': 'Object',
'privacy': 'string',
'profile_id': 'int',
'proxied_app_id': 'string',
'published': 'bool',
'qn': 'string',
'scheduled_publish_time': 'unsigned int',
'spherical_metadata': 'map',
'sponsor_id': 'string',
'sponsor_relationship': 'unsigned int',
'tags': 'list<Object>',
'target_id': 'int',
'targeting': 'Object',
'time_since_original_post': 'unsigned int',
'uid': 'int',
'unpublished_content_type': 'unpublished_content_type_enum',
'url': 'string',
'user_selected_tags': 'bool',
'vault_image_id': 'string',
}
enums = {
'backdated_time_granularity_enum': Photo.BackdatedTimeGranularity.__dict__.values(),
'unpublished_content_type_enum': Photo.UnpublishedContentType.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/photos',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Photo,
api_type='EDGE',
response_parser=ObjectParser(target_class=Photo, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_update(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'attached_media': 'list<Object>',
'backdated_time': 'datetime',
'backdated_time_granularity': 'backdated_time_granularity_enum',
'composer_session_id': 'string',
'direct_share_status': 'unsigned int',
'feed_story_visibility': 'feed_story_visibility_enum',
'is_explicit_location': 'bool',
'is_hidden': 'bool',
'is_pinned': 'bool',
'is_published': 'bool',
'message': 'string',
'og_action_type_id': 'string',
'og_hide_object_attachment': 'bool',
'og_icon_id': 'string',
'og_object_id': 'string',
'og_phrase': 'string',
'og_set_profile_badge': 'bool',
'og_suggestion_mechanism': 'string',
'place': 'Object',
'privacy': 'string',
'product_item': 'Object',
'scheduled_publish_time': 'unsigned int',
'should_sync_product_edit': 'bool',
'source_type': 'string',
'sponsor_id': 'string',
'sponsor_relationship': 'unsigned int',
'tags': 'list<int>',
'text_format_preset_id': 'string',
'timeline_visibility': 'timeline_visibility_enum',
'tracking': 'string',
}
enums = {
'backdated_time_granularity_enum': Post.BackdatedTimeGranularity.__dict__.values(),
'feed_story_visibility_enum': Post.FeedStoryVisibility.__dict__.values(),
'timeline_visibility_enum': Post.TimelineVisibility.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Post,
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_feed(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'actions': 'Object',
'adaptive_type': 'string',
'album_id': 'string',
'android_key_hash': 'string',
'animated_effect_id': 'unsigned int',
'application_id': 'string',
'asked_fun_fact_prompt_id': 'unsigned int',
'asset3d_id': 'unsigned int',
'associated_id': 'string',
'attach_place_suggestion': 'bool',
'attached_media': 'list<Object>',
'audience_exp': 'bool',
'backdated_time': 'datetime',
'backdated_time_granularity': 'backdated_time_granularity_enum',
'call_to_action': 'Object',
'caption': 'string',
'checkin_entry_point': 'checkin_entry_point_enum',
'child_attachments': 'list<Object>',
'client_mutation_id': 'string',
'composer_entry_picker': 'string',
'composer_entry_point': 'string',
'composer_entry_time': 'unsigned int',
'composer_session_events_log': 'string',
'composer_session_id': 'string',
'composer_source_surface': 'string',
'composer_type': 'string',
'connection_class': 'string',
'content_attachment': 'string',
'coordinates': 'Object',
'cta_link': 'string',
'cta_type': 'string',
'description': 'string',
'direct_share_status': 'unsigned int',
'expanded_height': 'unsigned int',
'expanded_width': 'unsigned int',
'feed_targeting': 'Object',
'formatting': 'formatting_enum',
'fun_fact_prompt_id': 'unsigned int',
'fun_fact_toastee_id': 'unsigned int',
'has_nickname': 'bool',
'height': 'unsigned int',
'holiday_card': 'string',
'home_checkin_city_id': 'Object',
'image_crops': 'map',
'implicit_with_tags': 'list<int>',
'instant_game_entry_point_data': 'string',
'ios_bundle_id': 'string',
'is_backout_draft': 'bool',
'is_boost_intended': 'bool',
'is_explicit_location': 'bool',
'is_explicit_share': 'bool',
'is_group_linking_post': 'bool',
'is_photo_container': 'bool',
'link': 'string',
'location_source_id': 'string',
'manual_privacy': 'bool',
'message': 'string',
'multi_share_end_card': 'bool',
'multi_share_optimized': 'bool',
'name': 'string',
'nectar_module': 'string',
'object_attachment': 'string',
'offer_like_post_id': 'unsigned int',
'og_action_type_id': 'string',
'og_hide_object_attachment': 'bool',
'og_icon_id': 'string',
'og_object_id': 'string',
'og_phrase': 'string',
'og_set_profile_badge': 'bool',
'og_suggestion_mechanism': 'string',
'page_recommendation': 'string',
'picture': 'string',
'place': 'Object',
'place_attachment_setting': 'place_attachment_setting_enum',
'place_list': 'string',
'place_list_data': 'list',
'post_surfaces_blacklist': 'list<post_surfaces_blacklist_enum>',
'posting_to_redspace': 'posting_to_redspace_enum',
'privacy': 'string',
'prompt_id': 'string',
'prompt_tracking_string': 'string',
'properties': 'Object',
'proxied_app_id': 'string',
'publish_event_id': 'unsigned int',
'published': 'bool',
'quote': 'string',
'react_mode_metadata': 'string',
'ref': 'list<string>',
'referenceable_image_ids': 'list<string>',
'referral_id': 'string',
'sales_promo_id': 'unsigned int',
'scheduled_publish_time': 'datetime',
'source': 'string',
'sponsor_id': 'string',
'sponsor_relationship': 'unsigned int',
'suggested_place_id': 'Object',
'tags': 'list<int>',
'target_surface': 'target_surface_enum',
'targeting': 'Object',
'text_format_metadata': 'string',
'text_format_preset_id': 'string',
'text_only_place': 'string',
'throwback_camera_roll_media': 'string',
'thumbnail': 'file',
'time_since_original_post': 'unsigned int',
'title': 'string',
'tracking_info': 'string',
'unpublished_content_type': 'unpublished_content_type_enum',
'user_selected_tags': 'bool',
'video_start_time_ms': 'unsigned int',
'viewer_coordinates': 'Object',
'width': 'unsigned int',
}
enums = {
'backdated_time_granularity_enum': [
'day',
'hour',
'min',
'month',
'none',
'year',
],
'checkin_entry_point_enum': [
'BRANDING_CHECKIN',
'BRANDING_OTHER',
'BRANDING_PHOTO',
'BRANDING_STATUS',
],
'formatting_enum': [
'MARKDOWN',
'PLAINTEXT',
],
'place_attachment_setting_enum': [
'1',
'2',
],
'post_surfaces_blacklist_enum': [
'1',
'2',
'3',
'4',
'5',
],
'posting_to_redspace_enum': [
'disabled',
'enabled',
],
'target_surface_enum': [
'STORY',
'TIMELINE',
],
'unpublished_content_type_enum': [
'ADS_POST',
'DRAFT',
'INLINE_CREATED',
'PUBLISHED',
'REVIEWABLE_BRANDED_CONTENT',
'SCHEDULED',
'SCHEDULED_RECURRING',
],
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/feed',
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_video(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.advideo import AdVideo
param_types = {
'adaptive_type': 'string',
'animated_effect_id': 'unsigned int',
'application_id': 'string',
'asked_fun_fact_prompt_id': 'unsigned int',
'attribution_app_id': 'string',
'audio_story_wave_animation_handle': 'string',
'composer_entry_picker': 'string',
'composer_entry_point': 'string',
'composer_entry_time': 'unsigned int',
'composer_session_events_log': 'string',
'composer_session_id': 'string',
'composer_source_surface': 'string',
'composer_type': 'string',
'container_type': 'container_type_enum',
'content_category': 'content_category_enum',
'description': 'string',
'embeddable': 'bool',
'end_offset': 'unsigned int',
'fbuploader_video_file_chunk': 'string',
'file_size': 'unsigned int',
'file_url': 'string',
'fisheye_video_cropped': 'bool',
'formatting': 'formatting_enum',
'fov': 'unsigned int',
'front_z_rotation': 'float',
'fun_fact_prompt_id': 'unsigned int',
'fun_fact_toastee_id': 'unsigned int',
'guide': 'list<list<unsigned int>>',
'guide_enabled': 'bool',
'has_nickname': 'bool',
'holiday_card': 'string',
'initial_heading': 'unsigned int',
'initial_pitch': 'unsigned int',
'instant_game_entry_point_data': 'string',
'is_boost_intended': 'bool',
'is_explicit_share': 'bool',
'is_group_linking_post': 'bool',
'is_voice_clip': 'bool',
'location_source_id': 'string',
'manual_privacy': 'bool',
'offer_like_post_id': 'unsigned int',
'og_action_type_id': 'string',
'og_icon_id': 'string',
'og_object_id': 'string',
'og_phrase': 'string',
'og_suggestion_mechanism': 'string',
'original_fov': 'unsigned int',
'original_projection_type': 'original_projection_type_enum',
'publish_event_id': 'unsigned int',
'react_mode_metadata': 'string',
'referenced_sticker_id': 'string',
'replace_video_id': 'string',
'sales_promo_id': 'unsigned int',
'scheduled_publish_time': 'unsigned int',
'slideshow_spec': 'map',
'source': 'string',
'spherical': 'bool',
'start_offset': 'unsigned int',
'swap_mode': 'swap_mode_enum',
'text_format_metadata': 'string',
'throwback_camera_roll_media': 'string',
'thumb': 'file',
'time_since_original_post': 'unsigned int',
'title': 'string',
'transcode_setting_properties': 'string',
'unpublished_content_type': 'unpublished_content_type_enum',
'upload_phase': 'upload_phase_enum',
'upload_session_id': 'string',
'upload_setting_properties': 'string',
'video_file_chunk': 'string',
'video_start_time_ms': 'unsigned int',
'waterfall_id': 'string',
}
enums = {
'container_type_enum': AdVideo.ContainerType.__dict__.values(),
'content_category_enum': AdVideo.ContentCategory.__dict__.values(),
'formatting_enum': AdVideo.Formatting.__dict__.values(),
'original_projection_type_enum': AdVideo.OriginalProjectionType.__dict__.values(),
'swap_mode_enum': AdVideo.SwapMode.__dict__.values(),
'unpublished_content_type_enum': AdVideo.UnpublishedContentType.__dict__.values(),
'upload_phase_enum': AdVideo.UploadPhase.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/videos',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=AdVideo,
api_type='EDGE',
response_parser=ObjectParser(target_class=AdVideo, api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_update(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'accountID': 'string',
'additionalMetadata': 'string',
'allowed_domains': 'list<string>',
'claim_objective': 'claim_objective_enum',
'content_type': 'content_type_enum',
'countries': 'string',
'customer_file_source': 'customer_file_source_enum',
'description': 'string',
'details': 'string',
'enable_fetch_or_create': 'bool',
'event_source_group': 'string',
'event_sources': 'list<map>',
'exclusions': 'list<Object>',
'expectedSize': 'unsigned int',
'gender': 'string',
'inclusions': 'list<Object>',
'isPrivate': 'bool',
'is_household': 'bool',
'is_household_exclusion': 'bool',
'lookalike_spec': 'string',
'maxAge': 'unsigned int',
'minAge': 'unsigned int',
'name': 'string',
'opt_out_link': 'string',
'parent_audience_id': 'unsigned int',
'partnerID': 'string',
'partner_reference_key': 'string',
'product_set_id': 'string',
'retention_days': 'unsigned int',
'rev_share_policy_id': 'unsigned int',
'rule': 'string',
'rule_aggregation': 'string',
'seed_audience': 'unsigned int',
'source': 'string',
'study_spec': 'map',
'tags': 'list<string>',
}
enums = {
'claim_objective_enum': CustomAudience.ClaimObjective.__dict__.values(),
'content_type_enum': CustomAudience.ContentType.__dict__.values(),
'customer_file_source_enum': CustomAudience.CustomerFileSource.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=CustomAudience,
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_update(self,
fields=None,
params=None,
batch=None,
success=None,
failure=None,
pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning(
'`success` and `failure` callback only work for batch call.')
param_types = {
'account_id': 'string',
'adlabels': 'list<Object>',
'adset_schedule': 'list<Object>',
'attribution_spec': 'list<map>',
'bid_adjustments': 'Object',
'bid_amount': 'int',
'bid_constraints': 'map<string, Object>',
'bid_strategy': 'bid_strategy_enum',
'billing_event': 'billing_event_enum',
'campaign_spec': 'Object',
'creative_sequence': 'list<string>',
'daily_budget': 'unsigned int',
'daily_imps': 'unsigned int',
'daily_min_spend_target': 'unsigned int',
'daily_spend_cap': 'unsigned int',
'date_format': 'string',
'destination_type': 'destination_type_enum',
'end_time': 'datetime',
'execution_options': 'list<execution_options_enum>',
'full_funnel_exploration_mode':
'full_funnel_exploration_mode_enum',
'lifetime_budget': 'unsigned int',
'lifetime_imps': 'unsigned int',
'lifetime_min_spend_target': 'unsigned int',
'lifetime_spend_cap': 'unsigned int',
'multi_optimization_goal_weight':
'multi_optimization_goal_weight_enum',
'name': 'string',
'optimization_goal': 'optimization_goal_enum',
'optimization_sub_event': 'optimization_sub_event_enum',
'pacing_type': 'list<string>',
'promoted_object': 'Object',
'rb_prediction_id': 'string',
'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>',
'time_start': 'datetime',
'time_stop': 'datetime',
'tune_for_category': 'tune_for_category_enum',
'upstream_events': 'map',
}
enums = {
'bid_strategy_enum':
AdSet.BidStrategy.__dict__.values(),
'billing_event_enum':
AdSet.BillingEvent.__dict__.values(),
'destination_type_enum':
AdSet.DestinationType.__dict__.values(),
'execution_options_enum':
AdSet.ExecutionOptions.__dict__.values(),
'full_funnel_exploration_mode_enum':
AdSet.FullFunnelExplorationMode.__dict__.values(),
'multi_optimization_goal_weight_enum':
AdSet.MultiOptimizationGoalWeight.__dict__.values(),
'optimization_goal_enum':
AdSet.OptimizationGoal.__dict__.values(),
'optimization_sub_event_enum':
AdSet.OptimizationSubEvent.__dict__.values(),
'status_enum':
AdSet.Status.__dict__.values(),
'tune_for_category_enum':
AdSet.TuneForCategory.__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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_promotion(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning('`success` and `failure` callback only work for batch call.')
param_types = {
'ad_account_id': 'string',
'ad_conversion_pixel_id': 'unsigned int',
'audience': 'audience_enum',
'audience_id': 'string',
'bid_amount': 'unsigned int',
'budget': 'unsigned int',
'cta_type': 'cta_type_enum',
'currency': 'string',
'flow_id': 'string',
'placement': 'string',
'start_time': 'unsigned int',
'stop_time': 'unsigned int',
'targeting': 'Targeting',
}
enums = {
'audience_enum': [
'AUTO_LOOKALIKE',
'AUTO_PAGE_LOOKALIKE',
'AUTO_TARGETING',
'CREATE_NEW',
'CUSTOM_AUDIENCE',
'DISTRICT',
'EVENT_CUSTOM_AUDIENCES',
'EVENT_ENGAGEMENT',
'FANS',
'GROUPER',
'IG_PROMOTED_POST_AUTO',
'LOCAL',
'LOOKALIKE',
'MULT_CUSTOM_AUDIENCES',
'NCPP',
'SAVED_AUDIENCE',
'SMART_AUDIENCE',
],
'cta_type_enum': [
'ADD_TO_CART',
'APPLY_NOW',
'BOOK_TRAVEL',
'BUY',
'BUY_NOW',
'BUY_TICKETS',
'CALL',
'CALL_ME',
'CONTACT',
'CONTACT_US',
'DONATE',
'DONATE_NOW',
'DOWNLOAD',
'EVENT_RSVP',
'FIND_A_GROUP',
'FIND_YOUR_GROUPS',
'FOLLOW_NEWS_STORYLINE',
'GET_DIRECTIONS',
'GET_OFFER',
'GET_OFFER_VIEW',
'GET_QUOTE',
'GET_SHOWTIMES',
'INSTALL_APP',
'INSTALL_MOBILE_APP',
'LEARN_MORE',
'LIKE_PAGE',
'LISTEN_MUSIC',
'LISTEN_NOW',
'MESSAGE_PAGE',
'MOBILE_DOWNLOAD',
'MOMENTS',
'NO_BUTTON',
'OPEN_LINK',
'ORDER_NOW',
'PLAY_GAME',
'RECORD_NOW',
'SAY_THANKS',
'SEE_MORE',
'SELL_NOW',
'SHARE',
'SHOP_NOW',
'SIGN_UP',
'SOTTO_SUBSCRIBE',
'SUBSCRIBE',
'UPDATE_APP',
'USE_APP',
'USE_MOBILE_APP',
'VIDEO_ANNOTATION',
'VISIT_PAGES_FEED',
'WATCH_MORE',
'WATCH_VIDEO',
'WHATSAPP_MESSAGE',
'WOODHENGE_SUPPORT',
],
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/promotions',
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def api_get(self,
fields=None,
params=None,
batch=None,
success=None,
failure=None,
pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning(
'`success` and `failure` callback only work for batch call.')
param_types = {
'am_call_tags': 'map',
'date_preset': 'date_preset_enum',
'from_adtable': 'bool',
'time_range': 'Object',
}
enums = {
'date_preset_enum': [
'last_14d',
'last_28d',
'last_30d',
'last_3d',
'last_7d',
'last_90d',
'last_month',
'last_quarter',
'last_week_mon_sun',
'last_week_sun_sat',
'last_year',
'lifetime',
'this_month',
'this_quarter',
'this_week_mon_today',
'this_week_sun_today',
'this_year',
'today',
'yesterday',
],
}
request = FacebookRequest(
node_id=self['id'],
method='GET',
endpoint='/',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=Campaign,
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_live_video(self,
fields=None,
params=None,
batch=None,
success=None,
failure=None,
pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning(
'`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.livevideo import LiveVideo
param_types = {
'content_tags': 'list<string>',
'description': 'string',
'encoding_settings': 'string',
'fisheye_video_cropped': 'bool',
'front_z_rotation': 'float',
'is_audio_only': 'bool',
'is_spherical': 'bool',
'live_encoders': 'list<string>',
'original_fov': 'unsigned int',
'planned_start_time': 'int',
'privacy': 'string',
'projection': 'projection_enum',
'published': 'bool',
'schedule_custom_profile_image': 'file',
'spatial_audio_format': 'spatial_audio_format_enum',
'status': 'status_enum',
'stereoscopic_mode': 'stereoscopic_mode_enum',
'stop_on_delete_stream': 'bool',
'stream_type': 'stream_type_enum',
'title': 'string',
}
enums = {
'projection_enum':
LiveVideo.Projection.__dict__.values(),
'spatial_audio_format_enum':
LiveVideo.SpatialAudioFormat.__dict__.values(),
'status_enum':
LiveVideo.Status.__dict__.values(),
'stereoscopic_mode_enum':
LiveVideo.StereoscopicMode.__dict__.values(),
'stream_type_enum':
LiveVideo.StreamType.__dict__.values(),
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/live_videos',
api=self._api,
param_checker=TypeChecker(param_types, enums),
target_class=LiveVideo,
api_type='EDGE',
response_parser=ObjectParser(target_class=LiveVideo,
api=self._api),
)
request.add_params(params)
request.add_fields(fields)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def get_insights_async(self,
fields=None,
params=None,
batch=None,
success=None,
failure=None,
pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning(
'`success` and `failure` callback only work for batch call.')
from facebook_business.adobjects.adreportrun import AdReportRun
from facebook_business.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<string>',
'filtering': 'list<Object>',
'level': 'level_enum',
'product_id_limit': 'int',
'sort': 'list<string>',
'summary': 'list<string>',
'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(),
'level_enum':
AdsInsights.Level.__dict__.values(),
'summary_action_breakdowns_enum':
AdsInsights.SummaryActionBreakdowns.__dict__.values(),
}
if fields is not None:
params['fields'] = params.get('fields') if params.get(
'fields') is not None else list()
params['fields'].extend(field for field in fields
if field not in params['fields'])
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)
if batch is not None:
request.add_to_batch(batch, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
def create_comment(self,
fields=None,
params=None,
batch=None,
success=None,
failure=None,
pending=False):
from facebook_business.utils import api_utils
if batch is None and (success is not None or failure is not None):
api_utils.warning(
'`success` and `failure` callback only work for batch call.')
param_types = {
'attachment_id': 'string',
'attachment_share_url': 'string',
'attachment_url': 'string',
'comment': 'string',
'comment_privacy_value': 'comment_privacy_value_enum',
'feedback_source': 'string',
'message': 'string',
'nectar_module': 'string',
'parent_comment_id': 'Object',
'post_id': 'string',
'tracking': 'string',
}
enums = {
'comment_privacy_value_enum': [
'DECLINED_BY_ADMIN_ASSISTANT',
'DEFAULT_PRIVACY',
'FRIENDS_AND_POST_OWNER',
'FRIENDS_ONLY',
'GRAPHQL_MULTIPLE_VALUE_HACK_DO_NOT_USE',
'OWNER_OR_COMMENTER',
'PENDING_APPROVAL',
'REMOVED_BY_ADMIN_ASSISTANT',
'SIDE_CONVERSATION',
'SIDE_CONVERSATION_AND_POST_OWNER',
'SPOTLIGHT_TAB',
],
}
request = FacebookRequest(
node_id=self['id'],
method='POST',
endpoint='/comments',
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, success=success, failure=failure)
return request
elif pending:
return request
else:
self.assure_call()
return request.execute()
