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 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 get_client_ad_accounts(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adaccount import AdAccount param_types = { } enums = { } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/client_ad_accounts', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdAccount, api_type='EDGE', response_parser=ObjectParser(target_class=AdAccount, api=self._api), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def create_ads_pixel(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adspixel import AdsPixel param_types = { 'name': 'string', } enums = { } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/adspixels', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdsPixel, api_type='EDGE', response_parser=ObjectParser(target_class=AdsPixel, api=self._api), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def invite_business_user(self, fields=None, params=None, batch=None, pending=False): param_types = { 'email': 'string', 'role': 'role_enum', } enums = { 'role_enum': [ 'ADMIN', 'EMPLOYEE', ], } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/business_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 get_stats(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adspixelstatsresult import AdsPixelStatsResult param_types = { 'aggregation': 'aggregation_enum', 'end_time': 'datetime', '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), ) 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 self.assure_call() 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 return request if pending else request.execute()
def get_ads(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.ad import Ad self.assure_call() param_types = { 'ad_draft_id': 'string', 'date_preset': 'date_preset_enum', 'effective_status': 'list<string>', 'include_deleted': 'bool', 'time_range': 'map', 'updated_since': 'int', } enums = { 'date_preset_enum': Ad.DatePreset.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/ads', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=Ad, api_type='EDGE', response_parser=ObjectParser(target_class=Ad), ) 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_activities(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adactivity import AdActivity self.assure_call() param_types = { 'after': 'string', 'business_id': 'string', 'category': 'category_enum', 'limit': 'int', 'since': 'datetime', 'uid': 'int', 'until': 'datetime', } enums = { 'category_enum': AdActivity.Category.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/activities', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdActivity, api_type='EDGE', response_parser=ObjectParser(target_class=AdActivity), ) 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_copies(self, fields=None, params=None, batch=None, pending=False): param_types = { 'date_preset': 'date_preset_enum', 'effective_status': 'list<effective_status_enum>', 'is_completed': 'bool', 'time_range': 'Object', } enums = { 'date_preset_enum': Campaign.DatePreset.__dict__.values(), 'effective_status_enum': Campaign.EffectiveStatus.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/copies', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=Campaign, api_type='EDGE', response_parser=ObjectParser(target_class=Campaign, api=self._api), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def get_samples(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.productfeeduploaderrorsample import ProductFeedUploadErrorSample 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, 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 = { 'app_event': 'string', 'app_id_for_app_event_firing': 'int', '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=OffsitePixel, 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_received_audience_permissions(self, fields=None, params=None, batch=None, pending=False): param_types = { 'partner_id': 'string', } enums = {} request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/received_audience_permissions', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AbstractCrudObject, api_type='EDGE', response_parser=ObjectParser(target_class=AbstractCrudObject), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def create_product_catalog(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.productcatalog import ProductCatalog param_types = { 'name': 'string', 'vertical': 'vertical_enum', } enums = { 'vertical_enum': ProductCatalog.Vertical.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/product_catalogs', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=ProductCatalog, api_type='EDGE', response_parser=ObjectParser(target_class=ProductCatalog), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def get_offline_conversion_data_sets(self, fields=None, params=None, batch=None, pending=False): 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=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_delete(self, fields=None, params=None, batch=None, pending=False): self.assure_call() param_types = { 'account_id': 'string', 'id': 'string', } 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 create_test_lead(self, fields=None, params=None, batch=None, pending=False): param_types = { 'custom_disclaimer_responses': 'list<Object>', 'field_data': 'list<Object>', } enums = {} request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/test_leads', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=LeadgenForm, api_type='EDGE', response_parser=ObjectParser(target_class=LeadgenForm, api=self._api), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def create_ad_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_accounts(self, fields=None, params=None, batch=None, pending=False): 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 elif pending: return request else: self.assure_call() return request.execute()
def get_async_ad_requests(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adasyncrequest import AdAsyncRequest self.assure_call() param_types = { 'statuses': 'list<statuses_enum>', } enums = { 'statuses_enum': AdAsyncRequest.Statuses.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/asyncadrequests', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdAsyncRequest, api_type='EDGE', response_parser=ObjectParser(target_class=AdAsyncRequest), ) 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 param_types = { 'accounts': 'map', '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 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_conversion_value': 'float', 'description': 'string', 'name': 'string', } 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_lead_gen_forms(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.leadgenform import LeadgenForm 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 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 api_update(self, fields=None, params=None, batch=None, pending=False): param_types = { 'address': 'Object', 'applinks': 'Object', 'brand': 'string', 'description': 'string', 'guest_ratings': 'list<Object>', 'images': 'list<Object>', 'name': 'string', 'phone': 'string', 'star_rating': 'float', 'url': 'string', } enums = {} request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=Hotel, 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_assigned_product_catalogs(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.productcatalog import ProductCatalog param_types = { 'email': 'string', 'user_id': 'int', } enums = { } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/assigned_product_catalogs', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=ProductCatalog, api_type='EDGE', response_parser=ObjectParser(target_class=ProductCatalog, 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_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=EventSourceGroup, 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_apps(self, fields=None, params=None, batch=None, pending=False): param_types = { 'app_id': 'int', } enums = { } request = FacebookRequest( node_id=self['id'], method='DELETE', endpoint='/apps', 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_products(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.productitem import ProductItem self.assure_call() param_types = { } enums = { } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/products', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=ProductItem, api_type='EDGE', response_parser=ObjectParser(target_class=ProductItem), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request return request if pending else request.execute()
def get_grp_plans(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.reachfrequencyprediction import ReachFrequencyPrediction param_types = { 'status': 'status_enum', } enums = { 'status_enum': ReachFrequencyPrediction.Status.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/grp_plans', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=ReachFrequencyPrediction, api_type='EDGE', response_parser=ObjectParser( target_class=ReachFrequencyPrediction), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def api_update(self, fields=None, params=None, batch=None, pending=False): self.assure_call() param_types = { '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 create_event_source_group(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.eventsourcegroup import EventSourceGroup param_types = { 'event_sources': 'list<string>', 'name': 'string', } enums = {} request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/event_source_groups', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=EventSourceGroup, api_type='EDGE', response_parser=ObjectParser(target_class=EventSourceGroup), ) 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 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 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 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 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 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 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 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 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 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_keyword_stats(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adkeywordstats import AdKeywordStats param_types = { 'date': 'datetime', } enums = { } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/keywordstats', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdKeywordStats, api_type='EDGE', response_parser=ObjectParser(target_class=AdKeywordStats), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def get_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 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): 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 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 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_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 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 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 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 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_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 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 delete_users(self, fields=None, params=None, batch=None, pending=False): param_types = { 'id': 'string', 'payload': 'Object', 'session': 'Object', } enums = { } request = FacebookRequest( node_id=self['id'], method='DELETE', 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()