def cancel_page_permission_request(self): request = FacebookRequest( node_id=self.get_parent_id_assured(), endpoint=self.get_endpoint(), api=self.get_api(), method='DELETE', ) request.add_params({'page_id': self.get_id_assured()}) request.execute()
def remove_user_permission(self, user_id, business_id): request = FacebookRequest( node_id=self.get_id_assured(), method='DELETE', endpoint=UserPagePermission.get_endpoint(), api=self.get_api(), ) request.add_params({'user': user_id, 'business': business_id}) request.execute()
def remote_delete( self, batch=None, failure=None, params=None, success=None, api_version=None, ): """Deletes the object by calling the API with the DELETE http method. Args: batch (optional): A FacebookAdsApiBatch object. If specified, the call will be added to the batch. params (optional): A mapping of request parameters where a key is the parameter name and its value is a string or an object which can be JSON-encoded. success (optional): A callback function which will be called with the FacebookResponse of this call if the call succeeded. failure (optional): A callback function which will be called with the FacebookResponse of this call if the call failed. Returns: self if not a batch call. the return value of batch.add if a batch call. """ if hasattr(self, 'api_delete'): request = self.api_delete(pending=True) else: request = FacebookRequest( node_id=self.get_id_assured(), method='DELETE', endpoint='/', api=self._api, ) request.add_params(params) if batch is not None: def callback_success(response): self.clear_id() if success: success(response) def callback_failure(response): if failure: failure(response) batch_call = batch.add_request( request=request, success=callback_success, failure=callback_failure, ) return batch_call else: request.execute() self.clear_id() return self
def remote_update(self, batch=None, failure=None, files=None, params=None, success=None, api_version=None): """Updates the object by calling the API with only the changes recorded. Args: batch (optional): A FacebookAdsApiBatch object. If specified, the call will be added to the batch. params (optional): A mapping of request parameters where a key is the parameter name and its value is a string or an object which can be JSON-encoded. files (optional): An optional mapping of file names to binary open file objects. These files will be attached to the request. success (optional): A callback function which will be called with the FacebookResponse of this call if the call succeeded. failure (optional): A callback function which will be called with the FacebookResponse of this call if the call failed. Returns: self if not a batch call. the return value of batch.add if a batch call. """ params = {} if not params else params.copy() params.update(self.export_changed_data()) self._set_data(params) if hasattr(self, "api_update"): request = self.api_update(pending=True) else: request = FacebookRequest( node_id=self.get_id_assured(), method="POST", endpoint="/", api=self._api, target_class=self.__class__, response_parser=ObjectParser(reuse_object=self), ) request.add_params(params) request.add_files(files) if batch is not None: def callback_success(response): self._clear_history() if success: success(response) def callback_failure(response): if failure: failure(response) batch_call = batch.add_request(request=request, success=callback_success, failure=callback_failure) return batch_call else: request.execute() self._clear_history() return self
def get_reach_estimate(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.reachestimate import ReachEstimate param_types = { 'currency': 'string', 'daily_budget': 'float', 'optimize_for': 'optimize_for_enum', } enums = { 'optimize_for_enum': ReachEstimate.OptimizeFor.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/reachestimate', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=ReachEstimate, api_type='EDGE', response_parser=ObjectParser(target_class=ReachEstimate), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def api_get(self, fields=None, params=None, batch=None, pending=False): param_types = { } enums = { } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdReportRun, api_type='NODE', response_parser=ObjectParser(reuse_object=self), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def get_previews(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adpreview import AdPreview param_types = { 'ad_format': 'ad_format_enum', 'height': 'unsigned int', 'locale': 'string', 'post': 'Object', 'product_item_ids': 'list<int>', 'width': 'unsigned int', } enums = { 'ad_format_enum': AdPreview.AdFormat.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/previews', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdPreview, api_type='EDGE', response_parser=ObjectParser(target_class=AdPreview), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def get_ad_sets(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adset import AdSet param_types = { "ad_draft_id": "string", "date_preset": "date_preset_enum", "effective_status": "list<effective_status_enum>", "is_completed": "bool", "time_range": "map", } 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), ) 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): self.assure_call() 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=AbstractCrudObject, api_type='EDGE', response_parser=ObjectParser(target_class=AbstractCrudObject), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request return request if pending else request.execute()
def api_update(self, fields=None, params=None, batch=None, pending=False): self.assure_call() param_types = { 'id': 'string', 'variants': 'list<Object>', } enums = { } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AbstractCrudObject, api_type='NODE', response_parser=ObjectParser(reuse_object=self), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request return request if pending else request.execute()
def create_ad_label(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adlabel import AdLabel param_types = {"adlabels": "list<Object>", "execution_options": "list<execution_options_enum>", "id": "string"} 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=AbstractCrudObject, api_type="EDGE", response_parser=ObjectParser(target_class=AbstractCrudObject), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def api_update(self, fields=None, params=None, batch=None, pending=False): param_types = { 'accounts': 'map', 'name': 'string', 'redownload': 'bool', 'status': 'unsigned int', 'users': 'map', } enums = { } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AbstractCrudObject, api_type='NODE', response_parser=ObjectParser(reuse_object=self), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def get_picture(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.profilepicturesource import ProfilePictureSource param_types = { 'height': 'int', 'redirect': 'bool', 'type': 'type_enum', 'width': 'int', } enums = { 'type_enum': ProfilePictureSource.Type.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/picture', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=ProfilePictureSource, api_type='EDGE', response_parser=ObjectParser(target_class=ProfilePictureSource, 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.adobjects.adlabel import AdLabel self.assure_call() param_types = { 'adlabels': 'list<Object>', 'execution_options': 'list<execution_options_enum>', 'id': 'string', } 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=AbstractCrudObject, api_type='EDGE', response_parser=ObjectParser(target_class=AbstractCrudObject), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request return request if pending else request.execute()
def get_ad_sets(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adset import AdSet self.assure_call() param_types = { 'ad_draft_id': 'string', 'date_preset': 'date_preset_enum', 'effective_status': 'list<effective_status_enum>', 'is_completed': 'bool', 'time_range': 'map', } 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), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request return request if pending else request.execute()
def create_ad_account_group(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adaccountgroup import AdAccountGroup self.assure_call() param_types = { 'accounts': 'map', 'id': 'int', 'name': 'string', 'redownload': 'bool', 'users': 'map', } enums = { } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/adaccountgroups', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdAccountGroup, api_type='EDGE', response_parser=ObjectParser(target_class=AdAccountGroup), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request return request if pending else request.execute()
def api_update(self, fields=None, params=None, batch=None, pending=False): self.assure_call() param_types = { 'adlabels': 'list<Object>', 'execution_options': 'list<execution_options_enum>', 'name': 'string', 'objective': 'objective_enum', 'promoted_object': 'Object', 'spend_cap': 'unsigned int', 'status': 'status_enum', } enums = { 'execution_options_enum': Campaign.ExecutionOptions.__dict__.values(), 'objective_enum': Campaign.Objective.__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=AbstractCrudObject, api_type='NODE', response_parser=ObjectParser(reuse_object=self), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request return request if pending else request.execute()
def get_promotable_events(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.event import Event self.assure_call() param_types = { 'is_page_event': 'bool', } 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), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request return request if pending else request.execute()
def create_user(self, fields=None, params=None, batch=None, pending=False): param_types = { 'account_group_roles': 'list<map>', 'redownload': 'bool', } enums = { } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/users', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AbstractCrudObject, api_type='EDGE', response_parser=ObjectParser(target_class=AbstractCrudObject), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def api_update(self, fields=None, params=None, batch=None, pending=False): param_types = { 'filter': 'Object', 'name': 'string', } enums = { } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=ProductSet, api_type='NODE', response_parser=ObjectParser(reuse_object=self), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def get_targeting_sentence_lines(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.targetingsentenceline import TargetingSentenceLine param_types = { } enums = { } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/targetingsentencelines', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=TargetingSentenceLine, api_type='EDGE', response_parser=ObjectParser(target_class=TargetingSentenceLine), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def get_ad_accounts(self, fields=None, params=None, batch=None, pending=False): param_types = { } enums = { } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/adaccounts', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AbstractCrudObject, api_type='EDGE', response_parser=ObjectParser(target_class=AbstractCrudObject), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def get_requests(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adasyncrequest import AdAsyncRequest param_types = { 'statuses': 'list<statuses_enum>', } enums = { 'statuses_enum': AdAsyncRequest.Statuses.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/requests', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdAsyncRequest, api_type='EDGE', response_parser=ObjectParser(target_class=AdAsyncRequest, api=self._api), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def get_lead_gen_forms(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.leadgenform import LeadgenForm self.assure_call() param_types = { '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), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request return request if pending else request.execute()
def get_product_sets(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.productset import ProductSet param_types = { } enums = { } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/product_sets', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=ProductSet, api_type='EDGE', response_parser=ObjectParser(target_class=ProductSet, 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_keyword_stats(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adkeywordstats import AdKeywordStats param_types = { 'date': 'datetime', } enums = { } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/keywordstats', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdKeywordStats, api_type='EDGE', response_parser=ObjectParser(target_class=AdKeywordStats), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def create_ad_label(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adlabel import AdLabel param_types = { 'adlabels': 'list<Object>', } enums = { } 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 api_update(self, fields=None, params=None, batch=None, pending=False): param_types = { 'account_id': 'string', 'adlabels': 'list<Object>', 'name': 'string', 'status': 'status_enum', } enums = { 'status_enum': AdCreative.Status.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdCreative, api_type='NODE', response_parser=ObjectParser(reuse_object=self), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def delete_ad_accounts(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adaccount import AdAccount self.assure_call() param_types = { 'adaccounts': 'list<string>', } enums = { } request = FacebookRequest( node_id=self['id'], method='DELETE', endpoint='/adaccounts', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdAccount, api_type='EDGE', response_parser=ObjectParser(target_class=AdAccount), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request return request if pending else request.execute()
def api_update(self, fields=None, params=None, batch=None, pending=False): self.assure_call() param_types = { 'app_event': 'string', 'app_id_for_app_event_firing': 'int', 'id': 'string', 'name': 'string', 'tag': 'tag_enum', } enums = { 'tag_enum': OffsitePixel.Tag.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AbstractCrudObject, api_type='NODE', response_parser=ObjectParser(reuse_object=self), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request return request if pending else request.execute()
def api_get(self, fields=None, params=None, batch=None, pending=False): param_types = {} enums = {} request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=ProductFeedUploadError, api_type='NODE', response_parser=ObjectParser(reuse_object=self), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def get_previews(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adpreview import AdPreview self.assure_call() param_types = { 'ad_format': 'ad_format_enum', 'height': 'unsigned int', 'locale': 'string', 'post': 'Object', 'product_item_ids': 'list<int>', 'width': 'unsigned int', } enums = { 'ad_format_enum': AdPreview.AdFormat.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/previews', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdPreview, api_type='EDGE', response_parser=ObjectParser(target_class=AdPreview), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request return request if pending else request.execute()
def api_update(self, fields=None, params=None, batch=None, pending=False): param_types = { 'applinks': 'Object', 'base_price': 'float', 'currency': 'string', 'description': 'string', 'images': 'list<Object>', 'margin_level': 'unsigned int', 'name': 'string', 'pricing_variables': 'list<Object>', 'sale_price': 'float', 'url': 'string', } enums = { } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=HotelRoom, api_type='NODE', response_parser=ObjectParser(reuse_object=self), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def create_ad_accounts(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adaccount import AdAccount param_types = { 'access_type': 'access_type_enum', 'adaccount_id': 'string', 'permitted_roles': 'list<permitted_roles_enum>', } enums = { 'access_type_enum': AdAccount.AccessType.__dict__.values(), 'permitted_roles_enum': AdAccount.PermittedRoles.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/adaccounts', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdAccount, api_type='EDGE', response_parser=ObjectParser(target_class=AdAccount), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def api_update(self, fields=None, params=None, batch=None, pending=False): param_types = { 'default_currency': 'string', 'deletion_enabled': 'bool', 'delimiter': 'delimiter_enum', 'encoding': 'encoding_enum', 'id': 'string', 'name': 'string', 'quoted_fields': 'bool', 'schedule': 'string', } enums = { 'delimiter_enum': ProductFeed.Delimiter.__dict__.values(), 'encoding_enum': ProductFeed.Encoding.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AbstractCrudObject, api_type='NODE', response_parser=ObjectParser(reuse_object=self), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def api_update(self, fields=None, params=None, batch=None, pending=False): param_types = { 'adlabels': 'list<Object>', 'execution_options': 'list<execution_options_enum>', 'name': 'string', 'objective': 'objective_enum', 'promoted_object': 'Object', 'spend_cap': 'unsigned int', 'status': 'status_enum', } enums = { 'execution_options_enum': Campaign.ExecutionOptions.__dict__.values(), 'objective_enum': Campaign.Objective.__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=AbstractCrudObject, api_type='NODE', response_parser=ObjectParser(reuse_object=self), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def get_system_users(self, fields=None, params=None, batch=None, pending=False): self.assure_call() param_types = { } enums = { } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/system_users', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AbstractCrudObject, api_type='EDGE', response_parser=ObjectParser(target_class=AbstractCrudObject), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request return request if pending else request.execute()
def get_access_token_debug_details(self, fields=None, params=None, batch=None, pending=False): param_types = { 'input_token': 'string', 'access_token': 'string', } enums = { } request = FacebookRequest( node_id='debug_token', method='GET', endpoint='/', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AbstractCrudObject, api_type='NODE', response_parser=ObjectParser(reuse_object=self), ) # TODO: Create an actual object instead of using AbstractCrudObject with this list.. request._accepted_fields = list(request._accepted_fields) request._accepted_fields.extend([ 'app_id', 'application', 'expires_at', 'is_valid', 'issued_at', 'scopes', 'user_id', 'type', 'profile_id' ]) 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_upload(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.productfeedupload import ProductFeedUpload param_types = { '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) return request elif pending: return request else: self.assure_call() return request.execute()
def api_delete(self, fields=None, params=None, batch=None, pending=False): self.assure_call() param_types = { 'id': 'int', } enums = {} request = FacebookRequest( node_id=self['id'], method='DELETE', endpoint='/', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AbstractCrudObject, api_type='NODE', response_parser=ObjectParser(reuse_object=self), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request return request if pending else request.execute()
def delete_ad_labels(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adlabel import AdLabel param_types = { 'adlabels': 'list<Object>', 'execution_options': 'list<execution_options_enum>', } enums = { 'execution_options_enum': AdLabel.ExecutionOptions.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='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) return request elif pending: return request else: self.assure_call() return request.execute()
def get_measurement_reports(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.measurementreport import MeasurementReport self.assure_call() param_types = { 'filters': 'list<Object>', 'report_type': 'report_type_enum', } enums = { 'report_type_enum': [ 'multi_channel_report', 'video_metrics_report', 'fruit_rollup_report', ], } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/measurement_reports', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AbstractCrudObject, api_type='EDGE', response_parser=ObjectParser(target_class=AbstractCrudObject), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request return request if pending else request.execute()
def create_objective(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adstudyobjective import AdStudyObjective param_types = { 'adspixels': 'list<Object>', 'applications': 'list<Object>', 'customconversions': 'list<Object>', 'is_primary': 'bool', 'name': 'string', 'offline_conversion_data_sets': 'list<Object>', 'offsitepixels': 'list<Object>', 'type': 'type_enum', } enums = { 'type_enum': AdStudyObjective.Type.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/objectives', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdStudyObjective, api_type='EDGE', response_parser=ObjectParser(target_class=AdStudyObjective, api=self._api), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def get_stats(self, fields=None, params=None, batch=None, pending=False): param_types = { 'aggr_time': 'aggr_time_enum', 'end': 'int', 'skip_empty_values': 'bool', 'start': 'int', 'user_timezone_id': 'unsigned int', } enums = { 'aggr_time_enum': [ 'upload_time', 'event_time', ], } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/stats', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AbstractCrudObject, api_type='EDGE', response_parser=ObjectParser(target_class=AbstractCrudObject, api=self._api), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def get_samples(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.productfeeduploaderrorsample import ProductFeedUploadErrorSample self.assure_call() param_types = {} enums = {} request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/samples', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=ProductFeedUploadErrorSample, api_type='EDGE', response_parser=ObjectParser( target_class=ProductFeedUploadErrorSample), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request return request if pending else request.execute()
def api_update(self, fields=None, params=None, batch=None, pending=False): self.assure_call() param_types = { 'adlabels': 'list<Object>', 'adset_id': 'unsigned int', 'bid_amount': 'int', 'creative': 'AdCreative', 'display_sequence': 'unsigned int', 'execution_options': 'list<execution_options_enum>', 'name': 'string', 'redownload': 'bool', 'status': 'status_enum', 'tracking_specs': 'Object', } enums = { 'execution_options_enum': Ad.ExecutionOptions.__dict__.values(), 'status_enum': Ad.Status.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AbstractCrudObject, api_type='NODE', response_parser=ObjectParser(reuse_object=self), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request return request if pending else request.execute()
def create_video(self, fields=None, params=None, batch=None, pending=False): param_types = { 'content_category': 'content_category_enum', 'description': 'string', 'embeddable': 'bool', 'file_size': 'unsigned int', 'file_url': 'string', 'fov': 'unsigned int', 'guide': 'list<list<unsigned int>>', 'guide_enabled': 'bool', 'initial_heading': 'unsigned int', 'initial_pitch': 'unsigned int', 'original_fov': 'unsigned int', 'original_projection_type': 'original_projection_type_enum', 'referenced_sticker_id': 'string', 'replace_video_id': 'string', 'slideshow_spec': 'map', 'source': 'string', 'spherical': 'bool', 'start_offset': 'unsigned int', 'swap_mode': 'swap_mode_enum', 'thumb': 'file', 'title': 'string', 'unpublished_content_type': 'unpublished_content_type_enum', 'upload_phase': 'upload_phase_enum', 'upload_session_id': 'string', 'video_file_chunk': 'string', } enums = { 'content_category_enum': [ 'BEAUTY_FASHION', 'BUSINESS', 'CARS_TRUCKS', 'COMEDY', 'CUTE_ANIMALS', 'ENTERTAINMENT', 'FAMILY', 'FOOD_HEALTH', 'HOME', 'LIFESTYLE', 'MUSIC', 'NEWS', 'POLITICS', 'SCIENCE', 'SPORTS', 'TECHNOLOGY', 'VIDEO_GAMING', 'OTHER', ], 'original_projection_type_enum': [ 'equirectangular', 'cubemap', 'equiangular_cubemap', ], 'swap_mode_enum': [ 'replace', ], 'unpublished_content_type_enum': [ 'SCHEDULED', 'DRAFT', 'ADS_POST', ], 'upload_phase_enum': [ 'start', 'transfer', 'finish', 'cancel', ], } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/videos', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AbstractCrudObject, api_type='EDGE', response_parser=ObjectParser(target_class=AbstractCrudObject, api=self._api), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def create_product(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.productitem import ProductItem param_types = { 'additional_image_urls': 'list<string>', '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', 'name': 'string', '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': 'unsigned int', '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='/products', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=ProductItem, api_type='EDGE', response_parser=ObjectParser(target_class=ProductItem), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
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) return request elif pending: return request else: self.assure_call() return request.execute() def get_insights_async(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adreportrun import AdReportRun from facebookads.adobjects.adsinsights import AdsInsights param_types = { 'action_attribution_windows': 'list<action_attribution_windows_enum>', 'action_breakdowns': 'list<action_breakdowns_enum>', 'action_report_time': 'action_report_time_enum', 'breakdowns': 'list<breakdowns_enum>', 'date_preset': 'date_preset_enum',
def remote_create( self, batch=None, failure=None, files=None, params=None, success=None, api_version=None, ): """Creates the object by calling the API. Args: batch (optional): A FacebookAdsApiBatch object. If specified, the call will be added to the batch. params (optional): A mapping of request parameters where a key is the parameter name and its value is a string or an object which can be JSON-encoded. files (optional): An optional mapping of file names to binary open file objects. These files will be attached to the request. success (optional): A callback function which will be called with the FacebookResponse of this call if the call succeeded. failure (optional): A callback function which will be called with the FacebookResponse of this call if the call failed. Returns: self if not a batch call. the return value of batch.add if a batch call. """ if self.get_id(): raise FacebookBadObjectError( "This %s object was already created." % self.__class__.__name__, ) if not 'get_endpoint' in dir(self): raise TypeError('Cannot create object of type %s.' % self.__class__.__name__) params = {} if not params else params.copy() params.update(self.export_all_data()) request = None if hasattr(self, 'api_create'): request = self.api_create(self.get_parent_id_assured(), pending=True) else: request = FacebookRequest( node_id=self.get_parent_id_assured(), method='POST', endpoint=self.get_endpoint(), api=self._api, target_class=self.__class__, response_parser=ObjectParser( reuse_object=self ), ) request.add_params(params) request.add_files(files) if batch is not None: def callback_success(response): self._set_data(response.json()) self._clear_history() if success: success(response) def callback_failure(response): if failure: failure(response) return batch.add_request( request=request, success=callback_success, failure=callback_failure, ) else: response = request.execute() self._set_data(response._json) self._clear_history() return self
def remote_update( self, batch=None, failure=None, files=None, params=None, success=None, api_version=None, ): """Updates the object by calling the API with only the changes recorded. Args: batch (optional): A FacebookAdsApiBatch object. If specified, the call will be added to the batch. params (optional): A mapping of request parameters where a key is the parameter name and its value is a string or an object which can be JSON-encoded. files (optional): An optional mapping of file names to binary open file objects. These files will be attached to the request. success (optional): A callback function which will be called with the FacebookResponse of this call if the call succeeded. failure (optional): A callback function which will be called with the FacebookResponse of this call if the call failed. Returns: self if not a batch call. the return value of batch.add if a batch call. """ params = {} if not params else params.copy() params.update(self.export_changed_data()) self._set_data(params) if hasattr(self, 'api_update'): request = self.api_update(pending=True) else: request = FacebookRequest( node_id=self.get_id_assured(), method='POST', endpoint='/', api=self._api, target_class=self.__class__, response_parser=ObjectParser( reuse_object=self ), ) request.add_params(params) request.add_files(files) if batch is not None: def callback_success(response): self._clear_history() if success: success(response) def callback_failure(response): if failure: failure(response) batch_call = batch.add_request( request=request, success=callback_success, failure=callback_failure, ) return batch_call else: request.execute() self._clear_history() return self
endpoint='/insights', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdsInsights, api_type='EDGE', response_parser=ObjectParser(target_class=AdsInsights), include_summary=False, ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request return request if pending else request.execute() def get_insights_async(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adreportrun import AdReportRun from facebookads.adobjects.adsinsights import AdsInsights self.assure_call() 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>',
def get_insights_async(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adreportrun import AdReportRun from facebookads.adobjects.adsinsights import AdsInsights self.assure_call() 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', 'fields': 'list<fields_enum>', 'filtering': 'list<Object>', 'level': 'level_enum', 'product_id_limit': 'int', 'sort': 'list<string>', 'summary': 'list<summary_enum>', 'summary_action_breakdowns': 'list<summary_action_breakdowns_enum>', 'time_increment': 'string', 'time_range': 'map', 'time_ranges': 'list<map>', } enums = { 'action_attribution_windows_enum': AdsInsights.ActionAttributionWindows.__dict__.values(), 'action_breakdowns_enum': AdsInsights.ActionBreakdowns.__dict__.values(), 'action_report_time_enum': AdsInsights.ActionReportTime.__dict__.values(), 'breakdowns_enum': AdsInsights.Breakdowns.__dict__.values(), 'date_preset_enum': AdsInsights.DatePreset.__dict__.values(), 'summary_enum': AdsInsights.Summary.__dict__.values(), 'level_enum': AdsInsights.Level.__dict__.values(), 'summary_action_breakdowns_enum': AdsInsights.SummaryActionBreakdowns.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/insights', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdReportRun, api_type='EDGE', response_parser=ObjectParser(target_class=AdReportRun), include_summary=False, ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request return request if pending else request.execute()