def create_hotel(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.hotel import Hotel param_types = { 'address': 'Object', 'applinks': 'Object', 'brand': 'string', 'description': 'string', 'guest_ratings': 'list<Object>', 'hotel_id': 'string', 'images': 'list<Object>', 'name': 'string', 'phone': 'string', 'star_rating': 'float', 'url': 'string', } enums = { } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/hotels', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=Hotel, api_type='EDGE', response_parser=ObjectParser(target_class=Hotel, 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.adaccount import AdAccount param_types = { 'billing_address_id': 'string', 'currency': 'string', 'end_advertiser': 'Object', 'funding_id': 'string', 'invoice': 'bool', 'io': 'bool', 'media_agency': 'string', 'name': 'string', 'partner': 'string', 'po_number': 'string', 'timezone_id': 'unsigned int', } enums = { } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/adaccount', 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 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<string>', '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_user_permission(self, fields=None, params=None, batch=None, pending=False): self.assure_call() param_types = { 'email': 'string', 'id': 'string', 'role': 'role_enum', 'user': '******', } enums = { 'role_enum': [ 'ADMIN', 'EMPLOYEE', 'SYSTEM_USER', 'ADMIN_SYSTEM_USER', 'INSTAGRAM_ADMIN', 'INSTAGRAM_EMPLOYEE', 'FB_EMPLOYEE_ACCOUNT_MANAGER', 'FB_EMPLOYEE_SALES_REP', ], } request = FacebookRequest( node_id=self['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 return request if pending else request.execute()
def create_businesse(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.business import Business param_types = { 'id': 'int', 'name': 'string', 'primary_page': 'string', 'sales_rep_email': 'string', 'survey_business_type': 'survey_business_type_enum', 'survey_num_assets': 'unsigned int', 'survey_num_people': 'unsigned int', 'timezone_id': 'unsigned int', 'vertical': 'vertical_enum', } enums = { 'survey_business_type_enum': Business.SurveyBusinessType.__dict__.values(), 'vertical_enum': Business.Vertical.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/businesses', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=Business, api_type='EDGE', response_parser=ObjectParser(target_class=Business), ) 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_permission(self, fields=None, params=None, batch=None, pending=False): param_types = { 'business': 'string', 'user': '******', 'role': 'role_enum', } enums = { 'role_enum': [ 'ADMIN', 'GENERAL_USER', 'REPORTS_ONLY', ], } request = FacebookRequest( node_id=self['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_activities(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adactivity import AdActivity param_types = { 'business_id': 'string', 'category': 'category_enum', '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, 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 = { '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=Ad, 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_extended_access_token(self, fields=None, params=None, batch=None, pending=False): param_types = { 'grant_type': 'string', 'client_id': 'string', 'client_secret': 'string', 'fb_exchange_token': 'string', } enums = {} request = FacebookRequest( node_id='oauth', method='GET', endpoint='/access_token', 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(['access_token', 'token_type']) 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_owned_product_catalog(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.productcatalog import ProductCatalog param_types = { 'da_display_settings': 'Object', 'destination_catalog_settings': 'map', 'flight_catalog_settings': 'map', 'name': 'string', 'vertical': 'vertical_enum', } enums = { 'vertical_enum': ProductCatalog.Vertical.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/owned_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_update(self, fields=None, params=None, batch=None, pending=False): param_types = { 'adlabels': 'list<Object>', 'budget_rebalance_flag': 'bool', '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=Campaign, api_type='NODE', response_parser=ObjectParser(reuse_object=self), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) 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): param_types = { 'filters': 'list<Object>', 'report_type': 'report_type_enum', } enums = { 'report_type_enum': [ 'multi_channel_report', 'video_metrics_report', 'fruit_rollup_report', 'third_party_mta_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 elif pending: return request else: self.assure_call() return request.execute()
def get_leads(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.lead import Lead self.assure_call() param_types = {} enums = {} request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/leads', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=Lead, api_type='EDGE', response_parser=ObjectParser(target_class=Lead), ) 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_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', '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=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_measurement_report(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.measurementreport import MeasurementReport self.assure_call() param_types = { 'id': 'Object', 'metadata': 'string', '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='POST', 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 api_update(self, fields=None, params=None, batch=None, pending=False): param_types = { 'content_type': 'content_type_enum', 'description': 'string', 'exclusions': 'list<Object>', 'inclusions': 'list<Object>', 'lookalike_spec': 'string', 'name': 'string', 'opt_out_link': 'string', 'product_set_id': 'string', 'retention_days': 'unsigned int', 'rule': 'string', } enums = { 'content_type_enum': CustomAudience.ContentType.__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 create_hotel_rooms_batch(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.productcataloghotelroomsbatch import ProductCatalogHotelRoomsBatch param_types = { 'file': 'file', 'standard': 'standard_enum', 'update_only': 'bool', } enums = { 'standard_enum': ProductCatalogHotelRoomsBatch.Standard.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/hotel_rooms_batch', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=ProductCatalogHotelRoomsBatch, api_type='EDGE', response_parser=ObjectParser( target_class=ProductCatalogHotelRoomsBatch), ) 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_delivery_estimate(self, fields=None, params=None, batch=None, pending=False): from facebookads.adobjects.adcampaigndeliveryestimate import AdCampaignDeliveryEstimate param_types = { 'optimization_goal': 'optimization_goal_enum', 'promoted_object': 'Object', 'targeting_spec': 'Targeting', } enums = { 'optimization_goal_enum': AdCampaignDeliveryEstimate.OptimizationGoal.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/delivery_estimate', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdCampaignDeliveryEstimate, api_type='EDGE', response_parser=ObjectParser( target_class=AdCampaignDeliveryEstimate, api=self._api), ) request.add_params(params) request.add_fields(fields) if batch is not None: request.add_to_batch(batch) return request elif pending: return request else: self.assure_call() return request.execute()
def get_user_permissions(self, fields=None, params=None, batch=None, pending=False): param_types = {} enums = {} request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/userpermissions', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AbstractCrudObject, api_type='EDGE', response_parser=ObjectParser(target_class=AbstractCrudObject), ) # TODO: Create an actual object instead of using AbstractCrudObject with this list.. request._accepted_fields = list(request._accepted_fields) request._accepted_fields.extend([ 'business_persona', 'status', 'user', 'role', 'email', 'created_by', 'updated_by', 'created_time', 'updated_time', 'page_permissions', 'adaccount_permissions' ]) 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_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 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 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 api_update(self, fields=None, params=None, batch=None, pending=False): param_types = {'name': 'string'} enums = {} request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=Project, 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_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_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_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 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_update(self, fields=None, params=None, batch=None, pending=False): param_types = { 'default_currency': 'string', 'deletion_enabled': 'bool', 'delimiter': 'delimiter_enum', 'encoding': 'encoding_enum', 'name': 'string', 'quoted_fields_mode': 'quoted_fields_mode_enum', 'schedule': 'string', } enums = { 'delimiter_enum': ProductFeed.Delimiter.__dict__.values(), 'encoding_enum': ProductFeed.Encoding.__dict__.values(), 'quoted_fields_mode_enum': ProductFeed.QuotedFieldsMode.__dict__.values(), } request = FacebookRequest( node_id=self['id'], method='POST', endpoint='/', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=ProductFeed, 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): self.assure_call() param_types = { } enums = { } request = FacebookRequest( node_id=self['id'], method='GET', endpoint='/', api=self._api, param_checker=TypeChecker(param_types, enums), target_class=AdAsyncRequest, 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_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()