def get_grp_plans(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.reachfrequencyprediction import ReachFrequencyPrediction param_types = { 'status': 'status_enum', } enums = { 'status_enum': ReachFrequencyPrediction.Status.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/grp_plans', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=ReachFrequencyPrediction, api_type='EDGE', response_parser=ObjectParser(target_class=ReachFrequencyPrediction, api=self._api), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def 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): 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_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 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 = { '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 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_stats(self, fields=None, params=None, batch=None, pending=False): param_types = { 'aggr_time': 'aggr_time_enum', 'end': 'int', 'skip_empty_values': 'bool', 'start': 'int', 'user_timezone_id': 'unsigned int', } enums = { 'aggr_time_enum': [ 'upload_time', 'event_time', ], } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/stats', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AbstractCrudObject, api_type='EDGE', response_parser=ObjectParser(target_class=AbstractCrudObject, api=self._api), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def create_test_lead(self, fields=None, params=None, batch=None, pending=False): param_types = { 'custom_disclaimer_responses': 'list<Object>', 'field_data': 'list<Object>', } enums = {} request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/test_leads', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=LeadgenForm, api_type='EDGE', response_parser=ObjectParser(target_class=LeadgenForm, api=self._api), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def create_ad_account(self, fields=None, params=None, batch=None, pending=False): param_types = { 'account_id': 'string', 'auto_track_for_ads': 'bool', 'business': 'string', } enums = { } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/adaccounts', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AbstractCrudObject, api_type='EDGE', response_parser=ObjectParser(target_class=AbstractCrudObject, api=self._api), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def create_event(self, fields=None, params=None, batch=None, pending=False): param_types = { 'data': 'list<Object>', 'namespace_id': 'string', 'progress': 'Object', 'upload_id': 'string', 'upload_tag': 'string', } enums = { } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/events', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AbstractCrudObject, api_type='EDGE', response_parser=ObjectParser(target_class=AbstractCrudObject, api=self._api), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def get_pending_owned_ad_accounts(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.legacybusinessadaccountrequest import LegacyBusinessAdAccountRequest param_types = {} enums = {} request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/pending_owned_ad_accounts', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=LegacyBusinessAdAccountRequest, api_type='EDGE', response_parser=ObjectParser( target_class=LegacyBusinessAdAccountRequest, api=self._api), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def create_offline_conversion_data_set(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.offlineconversiondataset import OfflineConversionDataSet param_types = { 'auto_assign_to_new_accounts_only': 'bool', 'description': 'string', 'enable_auto_assign_to_accounts': 'bool', 'name': 'string', } enums = {} request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/offline_conversion_data_sets', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=OfflineConversionDataSet, api_type='EDGE', response_parser=ObjectParser(target_class=OfflineConversionDataSet, api=self._api), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def get_offline_conversion_data_sets(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.offlineconversiondataset import OfflineConversionDataSet param_types = {} enums = {} request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/offline_conversion_data_sets', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=OfflineConversionDataSet, api_type='EDGE', response_parser=ObjectParser(target_class=OfflineConversionDataSet, api=self._api), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def get_sessions(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.customaudiencesession import CustomAudienceSession param_types = { 'session_id': 'unsigned int', } enums = { } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/sessions', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=CustomAudienceSession, api_type='EDGE', response_parser=ObjectParser(target_class=CustomAudienceSession), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def get_picture(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.profilepicturesource import ProfilePictureSource param_types = { 'height': 'int', 'redirect': 'bool', 'type': 'type_enum', 'width': 'int', } enums = { 'type_enum': ProfilePictureSource.Type.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/picture', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=ProfilePictureSource, api_type='EDGE', response_parser=ObjectParser(target_class=ProfilePictureSource), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def 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 create_ad_label(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adlabel import AdLabel param_types = { 'adlabels': 'list<Object>', 'execution_options': 'list<execution_options_enum>', } enums = { 'execution_options_enum': AdLabel.ExecutionOptions.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/adlabels', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdLabel, api_type='EDGE', response_parser=ObjectParser(target_class=AdLabel), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def 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 api_update(self, fields=None, params=None, batch=None, pending=False): param_types = { 'variants': 'list<Object>', } enums = { } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=ProductGroup, api_type='NODE', response_parser=ObjectParser(reuse_object=self), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def 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_get(self, fields=None, params=None, batch=None, pending=False): param_types = { } enums = { } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=ReachFrequencyPrediction, api_type='NODE', response_parser=ObjectParser(reuse_object=self), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def create_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 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=CustomConversion, 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 create_shared_agency(self, fields=None, params=None, batch=None, pending=False): param_types = { 'business': 'string', } enums = {} request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/shared_agencies', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=CustomConversion, api_type='EDGE', response_parser=ObjectParser(target_class=CustomConversion, 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_stats(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.customconversionstatsresult import CustomConversionStatsResult param_types = { 'aggregation': 'aggregation_enum', 'end_time': 'datetime', 'start_time': 'datetime', } enums = { 'aggregation_enum': CustomConversionStatsResult.Aggregation.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/stats', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=CustomConversionStatsResult, api_type='EDGE', response_parser=ObjectParser( target_class=CustomConversionStatsResult, 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_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_product_sets(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.productset import ProductSet self.assure_call() 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), ) 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 param_types = { 'effective_status': 'list<string>', } enums = { } 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 elif pending: return request else: self.assure_call() return request.execute()
def create_ad_account(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adaccount import AdAccount param_types = { 'adaccounts': 'list<string>', 'permissions': '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=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 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()
def get_sessions(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.customaudiencesession import CustomAudienceSession param_types = { 'session_id': 'unsigned int', } enums = {} request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/sessions', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=CustomAudienceSession, api_type='EDGE', response_parser=ObjectParser(target_class=CustomAudienceSession), ) 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 delete_users(self, fields=None, params=None, batch=None, pending=False): param_types = { 'namespace': '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()
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 create_user(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.user import User param_types = { 'namespace': 'string', 'payload': 'Object', 'session': 'Object', } enums = {} request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/users', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=User, api_type='EDGE', response_parser=ObjectParser(target_class=User), ) 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 claimPage(self, fields=None, params=None, batch=None, pending=False): param_types = { 'page_id': 'string', 'access_type': 'access_type_enum', 'user': '******', 'permitted_roles': 'list<permitted_roles_enum>' } enums = { 'access_type_enum': ['OWNER', 'AGENCY'], 'permitted_roles_enum': self.Roles.__dict__.values() } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/pages', 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_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 assign_people_to_page(self, fields=None, params=None, batch=None, pending=False): param_types = { 'business': 'string', 'role': 'role_enum', 'user': '******', 'page_id': 'string' } enums = {'role_enum': self.Roles.__dict__.values()} if 'page_id' not in params: raise AttributeError("Debes especificar 'page_id' como parámetro") request = FacebookRequest( node_id=params['page_id'], method='POST', endpoint='/userpermissions', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AbstractCrudObject, api_type='EDGE', response_parser=ObjectParser(target_class=AbstractCrudObject), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def 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 create_project(self, fields=None, params=None, batch=None, pending=False): param_types = {'name': 'string'} enums = {} request = FacebookRequest( node_id=self.get_id_assured(), method='POST', endpoint='/businessprojects', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=Project, 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): 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 api_delete(self, fields=None, params=None, batch=None, pending=False): 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 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 get_ads(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.ad import Ad 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 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_async_ad_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='/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 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_products(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.productitem import ProductItem param_types = { 'bulk_pagination': 'bool', 'filter': 'Object', } 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, api=self._api), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def create_ad_account_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_system_users(self, fields=None, params=None, batch=None, pending=False): 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 elif pending: return request else: self.assure_call() return request.execute()
def get_promotable_events(self, fields=None, params=None, batch=None, pending=False): from facebookads.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_ads_pixels(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adspixel import AdsPixel param_types = {} enums = {} request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/adspixels', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdsPixel, api_type='EDGE', response_parser=ObjectParser(target_class=AdsPixel), ) 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 create_ad_account(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.customaudienceadaccount import CustomAudienceAdAccount param_types = { 'adaccounts': 'list<string>', 'id': 'string', 'permissions': '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=CustomAudienceAdAccount, api_type='EDGE', response_parser=ObjectParser(target_class=CustomAudienceAdAccount), ) 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 create_event_source_group(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.eventsourcegroup import EventSourceGroup param_types = { 'event_sources': 'list<string>', 'name': 'string', } enums = {} request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/event_source_groups', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=EventSourceGroup, api_type='EDGE', response_parser=ObjectParser(target_class=EventSourceGroup, api=self._api), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()