Example #1
0
    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
Example #2
0
    def delete_users(self, fields=None, params=None, batch=None, pending=False):
        param_types = {
            'user_ids': 'list<int>',
        }
        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, 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()
Example #3
0
    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=PageLabel,
            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()
Example #4
0
    def create_user(self, fields=None, params=None, batch=None, pending=False):
        from facebook_business.adobjects.user import User
        param_types = {
            'user_ids': 'list<int>',
        }
        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, 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_question(self, fields=None, params=None, batch=None, pending=False):
        param_types = {
            'question': 'string',
            'options': 'list<string>',
            'correct_option': 'unsigned int',
        }
        enums = {
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/questions',
            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 = {
            'action': 'action_enum',
        }
        enums = {
            'action_enum': VideoGameShow.Action.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=VideoGameShow,
            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_product_catalogs(self, fields=None, params=None, batch=None, pending=False):
        from facebook_business.adobjects.productcatalog import ProductCatalog
        param_types = {
        }
        enums = {
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='GET',
            endpoint='/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 create_product_catalog(self, fields=None, params=None, batch=None, pending=False):
        param_types = {
            'product_catalog_id': 'string',
        }
        enums = {
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/product_catalogs',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=BusinessProject,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=BusinessProject, 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()
Example #9
0
    def create_user_permission(self, fields=None, params=None, batch=None, pending=False):
        param_types = {
            'role': 'role_enum',
            'user': '******',
        }
        enums = {
            'role_enum': [
                'ANALYST',
                'LIMITED_ANALYST',
            ],
        }
        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, 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()
Example #10
0
    def api_update(self, fields=None, params=None, batch=None, pending=False):
        param_types = {
            'event_sources': 'list<string>',
            'name': 'string',
        }
        enums = {
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            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 api_update(self, fields=None, params=None, batch=None, pending=False):
        param_types = {
            'published_ads': 'bool',
            'published': 'bool',
            'message': 'string',
        }
        enums = {
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=NativeOfferView,
            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()
Example #12
0
    def create_shared_account(self, fields=None, params=None, batch=None, pending=False):
        param_types = {
            'accounts': 'list<string>',
        }
        enums = {
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/shared_accounts',
            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()
    def api_get(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
          api_utils.warning('`success` and `failure` callback only work for batch call.')
        param_types = {
        }
        enums = {
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='GET',
            endpoint='/',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=PageAdminNote,
            api_type='NODE',
            response_parser=ObjectParser(reuse_object=self),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
    def create_photo(self, fields=None, params=None, batch=None, pending=False):
        param_types = {
            'urls': 'list<string>',
            'photos': 'list<string>',
            'ad_account': 'string',
            'ad_image_hashes': 'list<string>',
            'image_crops': 'list<map>',
            'file': 'file',
        }
        enums = {
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/photos',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=NativeOfferView,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=NativeOfferView, api=self._api),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
    def get_user_permissions(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
          api_utils.warning('`success` and `failure` callback only work for batch call.')
        param_types = {
            'user': '******',
        }
        enums = {
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='GET',
            endpoint='/userpermissions',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=AbstractCrudObject,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=AbstractCrudObject, api=self._api),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
    def create_user_permission(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
          api_utils.warning('`success` and `failure` callback only work for batch call.')
        param_types = {
            'tasks': 'list<tasks_enum>',
            'user': '******',
        }
        enums = {
            'tasks_enum': EventSourceGroup.Tasks.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/userpermissions',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=EventSourceGroup,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=EventSourceGroup, api=self._api),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
    def create_product_set(self, fields=None, params=None, batch=None, pending=False):
        from facebook_business.adobjects.productset import ProductSet
        param_types = {
            'filter': 'Object',
            'name': 'string',
        }
        enums = {
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            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):
        param_types = {
            'payload': 'file',
            'is_last_batch': 'bool',
            'url': 'string',
        }
        enums = {
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=MeasurementReport,
            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_hotels(self, fields=None, params=None, batch=None, pending=False):
        from facebook_business.adobjects.hotel import Hotel
        param_types = {
            'bulk_pagination': 'bool',
            'filter': 'Object',
        }
        enums = {
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='GET',
            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_pricing_variables_batch(self, fields=None, params=None, batch=None, pending=False):
        param_types = {
            'file': 'file',
            'password': '******',
            'standard': 'standard_enum',
            'url': 'string',
            'username': '******',
            'update_only': 'bool',
        }
        enums = {
            'standard_enum': ProductCatalog.Standard.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/pricing_variables_batch',
            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 get_event_stats(self, fields=None, params=None, batch=None, pending=False):
        from facebook_business.adobjects.producteventstat import ProductEventStat
        param_types = {
            'breakdowns': 'list<breakdowns_enum>',
        }
        enums = {
            'breakdowns_enum': ProductEventStat.Breakdowns.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='GET',
            endpoint='/event_stats',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=ProductEventStat,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=ProductEventStat, 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_external_event_sources(self, fields=None, params=None, batch=None, pending=False):
        from facebook_business.adobjects.externaleventsource import ExternalEventSource
        param_types = {
        }
        enums = {
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='GET',
            endpoint='/external_event_sources',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=ExternalEventSource,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=ExternalEventSource, 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_check_batch_request_status(self, fields=None, params=None, batch=None, pending=False):
        from facebook_business.adobjects.checkbatchrequeststatus import CheckBatchRequestStatus
        param_types = {
            'handle': 'string',
        }
        enums = {
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='GET',
            endpoint='/check_batch_request_status',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=CheckBatchRequestStatus,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=CheckBatchRequestStatus, 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_agency(self, fields=None, params=None, batch=None, pending=False):
        param_types = {
            'business': 'string',
            'permitted_roles': 'list<permitted_roles_enum>',
            'permitted_tasks': 'list<permitted_tasks_enum>',
        }
        enums = {
            'permitted_roles_enum': ProductCatalog.PermittedRoles.__dict__.values(),
            'permitted_tasks_enum': ProductCatalog.PermittedTasks.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/agencies',
            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 create_user_permission(self, fields=None, params=None, batch=None, pending=False):
        param_types = {
            'user': '******',
            'email': 'string',
            'role': 'role_enum',
            'business': 'string',
        }
        enums = {
            'role_enum': ProductCatalog.Role.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/userpermissions',
            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 = {
            'name': 'string',
            'default_image_url': 'string',
            'fallback_image_url': 'string',
            'flight_catalog_settings': 'map',
            'destination_catalog_settings': 'map',
            'da_display_settings': 'Object',
        }
        enums = {
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=ProductCatalog,
            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_rule(self, fields=None, params=None, batch=None, pending=False):
        from facebook_business.adobjects.productfeedrule import ProductFeedRule
        param_types = {
            'attribute': 'string',
            'params': 'map',
            'rule_type': 'rule_type_enum',
        }
        enums = {
            'rule_type_enum': ProductFeedRule.RuleType.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/rules',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=ProductFeedRule,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=ProductFeedRule, api=self._api),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
    def create_upload(self, fields=None, params=None, batch=None, pending=False):
        from facebook_business.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 get_da_event_samples(self, fields=None, params=None, batch=None, pending=False):
        from facebook_business.adobjects.productdaeventsamplesbatch import ProductDaEventSamplesBatch
        param_types = {
            'source_id': 'string',
            'event': 'event_enum',
            'aggregation_type': 'aggregation_type_enum',
        }
        enums = {
            'event_enum': ProductDaEventSamplesBatch.Event.__dict__.values(),
            'aggregation_type_enum': ProductDaEventSamplesBatch.AggregationType.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='GET',
            endpoint='/da_event_samples',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=ProductDaEventSamplesBatch,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=ProductDaEventSamplesBatch, 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()
Example #30
0
    def get_reactions(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
          api_utils.warning('`success` and `failure` callback only work for batch call.')
        from facebook_business.adobjects.profile import Profile
        param_types = {
            'type': 'type_enum',
        }
        enums = {
            'type_enum': Profile.Type.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='GET',
            endpoint='/reactions',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=Profile,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=Profile, api=self._api),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
Example #31
0
    def get_insights_async(self,
                           fields=None,
                           params=None,
                           batch=None,
                           success=None,
                           failure=None,
                           pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
            api_utils.warning(
                '`success` and `failure` callback only work for batch call.')
        from facebook_business.adobjects.adreportrun import AdReportRun
        from facebook_business.adobjects.adsinsights import AdsInsights
        param_types = {
            'action_attribution_windows':
            'list<action_attribution_windows_enum>',
            'action_breakdowns': 'list<action_breakdowns_enum>',
            'action_report_time': 'action_report_time_enum',
            'breakdowns': 'list<breakdowns_enum>',
            'date_preset': 'date_preset_enum',
            'default_summary': 'bool',
            'export_columns': 'list<string>',
            'export_format': 'string',
            'export_name': 'string',
            'fields': 'list<string>',
            'filtering': 'list<Object>',
            'level': 'level_enum',
            'product_id_limit': 'int',
            'sort': 'list<string>',
            'summary': 'list<string>',
            'summary_action_breakdowns':
            'list<summary_action_breakdowns_enum>',
            'time_increment': 'string',
            'time_range': 'Object',
            'time_ranges': 'list<Object>',
            'use_account_attribution_setting': 'bool',
        }
        enums = {
            'action_attribution_windows_enum':
            AdsInsights.ActionAttributionWindows.__dict__.values(),
            'action_breakdowns_enum':
            AdsInsights.ActionBreakdowns.__dict__.values(),
            'action_report_time_enum':
            AdsInsights.ActionReportTime.__dict__.values(),
            'breakdowns_enum':
            AdsInsights.Breakdowns.__dict__.values(),
            'date_preset_enum':
            AdsInsights.DatePreset.__dict__.values(),
            'level_enum':
            AdsInsights.Level.__dict__.values(),
            'summary_action_breakdowns_enum':
            AdsInsights.SummaryActionBreakdowns.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/insights',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=AdReportRun,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=AdReportRun,
                                         api=self._api),
            include_summary=False,
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
Example #32
0
    def api_update(self,
                   fields=None,
                   params=None,
                   batch=None,
                   success=None,
                   failure=None,
                   pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
            api_utils.warning(
                '`success` and `failure` callback only work for batch call.')
        param_types = {
            'ad_breaks': 'list',
            'allow_bm_crossposting': 'bool',
            'allow_crossposting_for_pages': 'list<Object>',
            'backdated_time': 'datetime',
            'backdated_time_granularity': 'backdated_time_granularity_enum',
            'call_to_action': 'Object',
            'content_category': 'content_category_enum',
            'content_tags': 'list<string>',
            'custom_labels': 'list<string>',
            'description': 'string',
            'direct_share_status': 'unsigned int',
            'embeddable': 'bool',
            'expiration': 'Object',
            'expire_now': 'bool',
            'increment_play_count': 'bool',
            'name': 'string',
            'preferred_thumbnail_id': 'string',
            'privacy': 'string',
            'publish_to_news_feed': 'bool',
            'publish_to_videos_tab': 'bool',
            'published': 'bool',
            'scheduled_publish_time': 'unsigned int',
            'social_actions': 'bool',
            'sponsor_id': 'string',
            'sponsor_relationship': 'unsigned int',
            'tags': 'list<string>',
            'target': 'string',
            'universal_video_id': 'string',
        }
        enums = {
            'backdated_time_granularity_enum':
            AdVideo.BackdatedTimeGranularity.__dict__.values(),
            'content_category_enum':
            AdVideo.ContentCategory.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=AdVideo,
            api_type='NODE',
            response_parser=ObjectParser(reuse_object=self),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
    def create_feed(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
          api_utils.warning('`success` and `failure` callback only work for batch call.')
        from facebook_business.adobjects.post import Post
        param_types = {
            'actions': 'Object',
            'adaptive_type': 'string',
            'album_id': 'string',
            'android_key_hash': 'string',
            'animated_effect_id': 'unsigned int',
            'application_id': 'string',
            'asked_fun_fact_prompt_id': 'unsigned int',
            'asset3d_id': 'unsigned int',
            'associated_id': 'string',
            'attach_place_suggestion': 'bool',
            'attached_media': 'list<Object>',
            'audience_exp': 'bool',
            'backdated_time': 'datetime',
            'backdated_time_granularity': 'backdated_time_granularity_enum',
            'call_to_action': 'Object',
            'caption': 'string',
            'checkin_entry_point': 'checkin_entry_point_enum',
            'child_attachments': 'list<Object>',
            'client_mutation_id': 'string',
            'composer_entry_picker': 'string',
            'composer_entry_point': 'string',
            'composer_entry_time': 'unsigned int',
            'composer_session_events_log': 'string',
            'composer_session_id': 'string',
            'composer_source_surface': 'string',
            'composer_type': 'string',
            'connection_class': 'string',
            'content_attachment': 'string',
            'coordinates': 'Object',
            'cta_link': 'string',
            'cta_type': 'string',
            'description': 'string',
            'direct_share_status': 'unsigned int',
            'expanded_height': 'unsigned int',
            'expanded_width': 'unsigned int',
            'feed_targeting': 'Object',
            'formatting': 'formatting_enum',
            'fun_fact_prompt_id': 'unsigned int',
            'fun_fact_toastee_id': 'unsigned int',
            'has_nickname': 'bool',
            'height': 'unsigned int',
            'holiday_card': 'string',
            'home_checkin_city_id': 'Object',
            'image_crops': 'map',
            'implicit_with_tags': 'list<int>',
            'instant_game_entry_point_data': 'string',
            'ios_bundle_id': 'string',
            'is_backout_draft': 'bool',
            'is_boost_intended': 'bool',
            'is_explicit_location': 'bool',
            'is_explicit_share': 'bool',
            'is_group_linking_post': 'bool',
            'is_photo_container': 'bool',
            'link': 'string',
            'location_source_id': 'string',
            'manual_privacy': 'bool',
            'message': 'string',
            'multi_share_end_card': 'bool',
            'multi_share_optimized': 'bool',
            'name': 'string',
            'nectar_module': 'string',
            'object_attachment': 'string',
            'offer_like_post_id': 'unsigned int',
            'og_action_type_id': 'string',
            'og_hide_object_attachment': 'bool',
            'og_icon_id': 'string',
            'og_object_id': 'string',
            'og_phrase': 'string',
            'og_set_profile_badge': 'bool',
            'og_suggestion_mechanism': 'string',
            'page_recommendation': 'string',
            'picture': 'string',
            'place': 'Object',
            'place_attachment_setting': 'place_attachment_setting_enum',
            'place_list': 'string',
            'place_list_data': 'list',
            'post_surfaces_blacklist': 'list<post_surfaces_blacklist_enum>',
            'posting_to_redspace': 'posting_to_redspace_enum',
            'privacy': 'string',
            'prompt_id': 'string',
            'prompt_tracking_string': 'string',
            'properties': 'Object',
            'proxied_app_id': 'string',
            'publish_event_id': 'unsigned int',
            'published': 'bool',
            'quote': 'string',
            'react_mode_metadata': 'string',
            'ref': 'list<string>',
            'referenceable_image_ids': 'list<string>',
            'referral_id': 'string',
            'sales_promo_id': 'unsigned int',
            'scheduled_publish_time': 'datetime',
            'source': 'string',
            'sponsor_id': 'string',
            'sponsor_relationship': 'unsigned int',
            'suggested_place_id': 'Object',
            'tags': 'list<int>',
            'target_surface': 'target_surface_enum',
            'targeting': 'Object',
            'text_format_metadata': 'string',
            'text_format_preset_id': 'string',
            'text_only_place': 'string',
            'throwback_camera_roll_media': 'string',
            'thumbnail': 'file',
            'time_since_original_post': 'unsigned int',
            'title': 'string',
            'tracking_info': 'string',
            'unpublished_content_type': 'unpublished_content_type_enum',
            'user_selected_tags': 'bool',
            'video_start_time_ms': 'unsigned int',
            'viewer_coordinates': 'Object',
            'width': 'unsigned int',
        }
        enums = {
            'backdated_time_granularity_enum': Post.BackdatedTimeGranularity.__dict__.values(),
            'checkin_entry_point_enum': Post.CheckinEntryPoint.__dict__.values(),
            'formatting_enum': Post.Formatting.__dict__.values(),
            'place_attachment_setting_enum': Post.PlaceAttachmentSetting.__dict__.values(),
            'post_surfaces_blacklist_enum': Post.PostSurfacesBlacklist.__dict__.values(),
            'posting_to_redspace_enum': Post.PostingToRedspace.__dict__.values(),
            'target_surface_enum': Post.TargetSurface.__dict__.values(),
            'unpublished_content_type_enum': Post.UnpublishedContentType.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/feed',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=Post,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=Post, api=self._api),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
    def create_video(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
          api_utils.warning('`success` and `failure` callback only work for batch call.')
        from facebook_business.adobjects.advideo import AdVideo
        param_types = {
            'adaptive_type': 'string',
            'animated_effect_id': 'unsigned int',
            'application_id': 'string',
            'asked_fun_fact_prompt_id': 'unsigned int',
            'audio_story_wave_animation_handle': 'string',
            'composer_entry_picker': 'string',
            'composer_entry_point': 'string',
            'composer_entry_time': 'unsigned int',
            'composer_session_events_log': 'string',
            'composer_session_id': 'string',
            'composer_source_surface': 'string',
            'composer_type': 'string',
            'container_type': 'container_type_enum',
            'content_category': 'content_category_enum',
            'creative_tools': 'string',
            'description': 'string',
            'embeddable': 'bool',
            'end_offset': 'unsigned int',
            'fbuploader_video_file_chunk': 'string',
            'file_size': 'unsigned int',
            'file_url': 'string',
            'fisheye_video_cropped': 'bool',
            'formatting': 'formatting_enum',
            'fov': 'unsigned int',
            'front_z_rotation': 'float',
            'fun_fact_prompt_id': 'unsigned int',
            'fun_fact_toastee_id': 'unsigned int',
            'guide': 'list<list<unsigned int>>',
            'guide_enabled': 'bool',
            'has_nickname': 'bool',
            'holiday_card': 'string',
            'initial_heading': 'unsigned int',
            'initial_pitch': 'unsigned int',
            'instant_game_entry_point_data': 'string',
            'is_boost_intended': 'bool',
            'is_explicit_share': 'bool',
            'is_group_linking_post': 'bool',
            'is_voice_clip': 'bool',
            'location_source_id': 'string',
            'manual_privacy': 'bool',
            'offer_like_post_id': 'unsigned int',
            'og_action_type_id': 'string',
            'og_icon_id': 'string',
            'og_object_id': 'string',
            'og_phrase': 'string',
            'og_suggestion_mechanism': 'string',
            'original_fov': 'unsigned int',
            'original_projection_type': 'original_projection_type_enum',
            'publish_event_id': 'unsigned int',
            'react_mode_metadata': 'string',
            'referenced_sticker_id': 'string',
            'replace_video_id': 'string',
            'sales_promo_id': 'unsigned int',
            'scheduled_publish_time': 'unsigned int',
            'slideshow_spec': 'map',
            'source': 'string',
            'source_instagram_media_id': 'string',
            'spherical': 'bool',
            'start_offset': 'unsigned int',
            'swap_mode': 'swap_mode_enum',
            'text_format_metadata': 'string',
            'throwback_camera_roll_media': 'string',
            'thumb': 'file',
            'time_since_original_post': 'unsigned int',
            'title': 'string',
            'transcode_setting_properties': 'string',
            'unpublished_content_type': 'unpublished_content_type_enum',
            'upload_phase': 'upload_phase_enum',
            'upload_session_id': 'string',
            'upload_setting_properties': 'string',
            'video_file_chunk': 'string',
            'video_id_original': 'string',
            'video_start_time_ms': 'unsigned int',
            'waterfall_id': 'string',
        }
        enums = {
            'container_type_enum': AdVideo.ContainerType.__dict__.values(),
            'content_category_enum': AdVideo.ContentCategory.__dict__.values(),
            'formatting_enum': AdVideo.Formatting.__dict__.values(),
            'original_projection_type_enum': AdVideo.OriginalProjectionType.__dict__.values(),
            'swap_mode_enum': AdVideo.SwapMode.__dict__.values(),
            'unpublished_content_type_enum': AdVideo.UnpublishedContentType.__dict__.values(),
            'upload_phase_enum': AdVideo.UploadPhase.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/videos',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=AdVideo,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=AdVideo, api=self._api),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
Example #35
0
    def api_update(self,
                   fields=None,
                   params=None,
                   batch=None,
                   success=None,
                   failure=None,
                   pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
            api_utils.warning(
                '`success` and `failure` callback only work for batch call.')
        param_types = {
            'attached_media': 'list<Object>',
            'backdated_time': 'datetime',
            'backdated_time_granularity': 'backdated_time_granularity_enum',
            'composer_session_id': 'string',
            'direct_share_status': 'unsigned int',
            'feed_story_visibility': 'feed_story_visibility_enum',
            'is_explicit_location': 'bool',
            'is_hidden': 'bool',
            'is_pinned': 'bool',
            'is_published': 'bool',
            'message': 'string',
            'og_action_type_id': 'string',
            'og_hide_object_attachment': 'bool',
            'og_icon_id': 'string',
            'og_object_id': 'string',
            'og_phrase': 'string',
            'og_set_profile_badge': 'bool',
            'og_suggestion_mechanism': 'string',
            'place': 'Object',
            'privacy': 'string',
            'product_item': 'Object',
            'scheduled_publish_time': 'unsigned int',
            'should_sync_product_edit': 'bool',
            'source_type': 'string',
            'sponsor_id': 'string',
            'sponsor_relationship': 'unsigned int',
            'tags': 'list<int>',
            'text_format_preset_id': 'string',
            'timeline_visibility': 'timeline_visibility_enum',
            'tracking': 'string',
        }
        enums = {
            'backdated_time_granularity_enum':
            PagePost.BackdatedTimeGranularity.__dict__.values(),
            'feed_story_visibility_enum':
            PagePost.FeedStoryVisibility.__dict__.values(),
            'timeline_visibility_enum':
            PagePost.TimelineVisibility.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=PagePost,
            api_type='NODE',
            response_parser=ObjectParser(reuse_object=self),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
    def api_update(self,
                   fields=None,
                   params=None,
                   batch=None,
                   success=None,
                   failure=None,
                   pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
            api_utils.warning(
                '`success` and `failure` callback only work for batch call.')
        param_types = {
            'ad_accounts_info': 'list<Object>',
            'additional_comment': 'string',
            'address_in_chinese': 'string',
            'address_in_english': 'Object',
            'address_in_local_language': 'string',
            'advertiser_business_id': 'string',
            'business_registration': 'file',
            'business_registration_id': 'string',
            'chinese_legal_entity_name': 'string',
            'contact': 'Object',
            'disapprove_appeal_comment': 'string',
            'english_legal_entity_name': 'string',
            'extended_credit_id': 'string',
            'is_smb': 'bool',
            'legal_entity_name_in_local_language': 'string',
            'official_website_url': 'string',
            'planning_agency_business_id': 'string',
            'promotable_app_ids': 'list<string>',
            'promotable_page_ids': 'list<string>',
            'promotable_page_urls': 'list<string>',
            'promotable_urls': 'list<string>',
            'subvertical': 'subvertical_enum',
            'vertical': 'vertical_enum',
        }
        enums = {
            'subvertical_enum':
            AdAccountCreationRequest.Subvertical.__dict__.values(),
            'vertical_enum':
            AdAccountCreationRequest.Vertical.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=AdAccountCreationRequest,
            api_type='NODE',
            response_parser=ObjectParser(reuse_object=self),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
Example #37
0
    def api_update(self,
                   fields=None,
                   params=None,
                   batch=None,
                   success=None,
                   failure=None,
                   pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
            api_utils.warning(
                '`success` and `failure` callback only work for batch call.')
        param_types = {
            'additional_image_files': 'list<file>',
            'additional_image_urls': 'list<string>',
            'additional_variant_attributes': 'map',
            'android_app_name': 'string',
            'android_class': 'string',
            'android_package': 'string',
            'android_url': 'string',
            'availability': 'availability_enum',
            'brand': 'string',
            'category': 'string',
            'checkout_url': 'string',
            'color': 'string',
            'commerce_tax_category': 'commerce_tax_category_enum',
            'condition': 'condition_enum',
            'currency': 'string',
            'custom_data': 'map',
            'custom_label_0': 'string',
            'custom_label_1': 'string',
            'custom_label_2': 'string',
            'custom_label_3': 'string',
            'custom_label_4': 'string',
            'description': 'string',
            'expiration_date': 'string',
            'gender': 'gender_enum',
            'gtin': 'string',
            'image_url': 'string',
            'inventory': 'unsigned int',
            'ios_app_name': 'string',
            'ios_app_store_id': 'unsigned int',
            'ios_url': 'string',
            'ipad_app_name': 'string',
            'ipad_app_store_id': 'unsigned int',
            'ipad_url': 'string',
            'iphone_app_name': 'string',
            'iphone_app_store_id': 'unsigned int',
            'iphone_url': 'string',
            'launch_date': 'string',
            'manufacturer_part_number': 'string',
            'material': 'string',
            'mobile_link': 'string',
            'name': 'string',
            'offer_price_amount': 'unsigned int',
            'offer_price_end_date': 'datetime',
            'offer_price_start_date': 'datetime',
            'ordering_index': 'unsigned int',
            'pattern': 'string',
            'price': 'unsigned int',
            'product_type': 'string',
            'retailer_id': 'string',
            'return_policy_days': 'unsigned int',
            'sale_price': 'unsigned int',
            'sale_price_end_date': 'datetime',
            'sale_price_start_date': 'datetime',
            'short_description': 'string',
            'size': 'string',
            'start_date': 'string',
            'url': 'string',
            'visibility': 'visibility_enum',
            'windows_phone_app_id': 'string',
            'windows_phone_app_name': 'string',
            'windows_phone_url': 'string',
        }
        enums = {
            'availability_enum':
            ProductItem.Availability.__dict__.values(),
            'commerce_tax_category_enum':
            ProductItem.CommerceTaxCategory.__dict__.values(),
            'condition_enum':
            ProductItem.Condition.__dict__.values(),
            'gender_enum':
            ProductItem.Gender.__dict__.values(),
            'visibility_enum':
            ProductItem.Visibility.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=ProductItem,
            api_type='NODE',
            response_parser=ObjectParser(reuse_object=self),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
Example #38
0
    def create_promotion(self,
                         fields=None,
                         params=None,
                         batch=None,
                         success=None,
                         failure=None,
                         pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
            api_utils.warning(
                '`success` and `failure` callback only work for batch call.')
        param_types = {
            'ad_account_id': 'string',
            'ad_conversion_pixel_id': 'unsigned int',
            'audience': 'audience_enum',
            'audience_id': 'string',
            'bid_amount': 'unsigned int',
            'budget': 'unsigned int',
            'cta_type': 'cta_type_enum',
            'currency': 'string',
            'flow_id': 'string',
            'placement': 'string',
            'start_time': 'unsigned int',
            'stop_time': 'unsigned int',
            'targeting': 'Targeting',
        }
        enums = {
            'audience_enum': [
                'AUTO_LOOKALIKE',
                'AUTO_PAGE_LOOKALIKE',
                'AUTO_TARGETING',
                'COUNTRY_AND_INTEREST',
                'CREATE_NEW',
                'CUSTOM_AUDIENCE',
                'DISTRICT',
                'EVENT_CUSTOM_AUDIENCES',
                'EVENT_ENGAGEMENT',
                'FANS',
                'GROUPER',
                'HEC_AUDIENCE',
                'IG_PROMOTED_POST_AUTO',
                'LOCAL',
                'LOOKALIKE',
                'MARKETPLACE_DEFAULT',
                'MARKETPLACE_NATIONWIDE_AUDIENCE',
                'MARKETPLACE_SAVED_AUDIENCE',
                'MULT_CUSTOM_AUDIENCES',
                'NCPP',
                'SAVED_AUDIENCE',
                'SMART_AUDIENCE',
            ],
            'cta_type_enum': [
                'ADD_TO_CART',
                'APPLY_NOW',
                'BOOK_TRAVEL',
                'BUY',
                'BUY_NOW',
                'BUY_TICKETS',
                'CALL',
                'CALL_ME',
                'CONTACT',
                'CONTACT_US',
                'DONATE',
                'DONATE_NOW',
                'DOWNLOAD',
                'EVENT_RSVP',
                'FIND_A_GROUP',
                'FIND_YOUR_GROUPS',
                'FOLLOW_NEWS_STORYLINE',
                'FOLLOW_PAGE',
                'FOLLOW_USER',
                'GET_DIRECTIONS',
                'GET_OFFER',
                'GET_OFFER_VIEW',
                'GET_QUOTE',
                'GET_SHOWTIMES',
                'INSTALL_APP',
                'INSTALL_MOBILE_APP',
                'LEARN_MORE',
                'LIKE_PAGE',
                'LISTEN_MUSIC',
                'LISTEN_NOW',
                'MESSAGE_PAGE',
                'MOBILE_DOWNLOAD',
                'MOMENTS',
                'NO_BUTTON',
                'OPEN_LINK',
                'ORDER_NOW',
                'PAY_TO_ACCESS',
                'PLAY_GAME',
                'PURCHASE_GIFT_CARDS',
                'RECORD_NOW',
                'REQUEST_TIME',
                'SAY_THANKS',
                'SEE_MORE',
                'SELL_NOW',
                'SEND_A_GIFT',
                'SHARE',
                'SHOP_NOW',
                'SIGN_UP',
                'SOTTO_SUBSCRIBE',
                'SUBSCRIBE',
                'UPDATE_APP',
                'USE_APP',
                'USE_MOBILE_APP',
                'VIDEO_ANNOTATION',
                'VISIT_PAGES_FEED',
                'WATCH_MORE',
                'WATCH_VIDEO',
                'WHATSAPP_MESSAGE',
                'WOODHENGE_SUPPORT',
            ],
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/promotions',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=AbstractCrudObject,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=AbstractCrudObject,
                                         api=self._api),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
        if async:
            return self.get_insights_async(fields, params, batch, pending)
        param_types = {
            'metric': 'list<metric_enum>',
            'period': 'list<period_enum>',
        }
        enums = {
            'metric_enum': InstagramInsightsResult.Metric.__dict__.values(),
            'period_enum': InstagramInsightsResult.Period.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='GET',
            endpoint='/insights',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=InstagramInsightsResult,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=InstagramInsightsResult,
                                         api=self._api),
            include_summary=False,
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
    def get_conversion_paths(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
          api_utils.warning('`success` and `failure` callback only work for batch call.')
        param_types = {
            'click_lookback_window': 'unsigned int',
            'date_range': 'Object',
            'fb_conversion_event_id': 'unsigned int',
            'limit': 'unsigned int',
            'metric_context': 'map',
            'time_period': 'time_period_enum',
            'view_lookback_window': 'unsigned int',
        }
        enums = {
            'time_period_enum': [
                'all_available',
                'all_dates',
                'custom',
                'date_range',
                'fifteen_days',
                'last_fourteen_days',
                'last_hundred_fourty_four_hours',
                'last_month',
                'last_ninety_days',
                'last_quarter',
                'last_seven_days',
                'last_sixty_days',
                'last_thirty_days',
                'last_twenty_four_hours',
                'last_year',
                'month_to_date',
                'quarter_to_date',
                'seven_days',
                'thirty_days',
                'this_month_whole_days',
                'today',
                'week_to_date',
                'year_to_date',
                'yesterday',
            ],
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='GET',
            endpoint='/conversion_paths',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=AbstractCrudObject,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=AbstractCrudObject, api=self._api),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
Example #41
0
    def create_product(self,
                       fields=None,
                       params=None,
                       batch=None,
                       pending=False):
        from facebook_business.adobjects.productitem import ProductItem
        param_types = {
            'additional_image_urls': 'list<string>',
            'additional_variant_attributes': 'Object',
            'android_app_name': 'string',
            'android_class': 'string',
            'android_package': 'string',
            'android_url': 'string',
            'availability': 'availability_enum',
            'brand': 'string',
            'category': 'string',
            'checkout_url': 'string',
            'color': 'string',
            'condition': 'condition_enum',
            'currency': 'string',
            'custom_data': 'map',
            'custom_label_0': 'string',
            'custom_label_1': 'string',
            'custom_label_2': 'string',
            'custom_label_3': 'string',
            'custom_label_4': 'string',
            'description': 'string',
            'expiration_date': 'string',
            'gender': 'gender_enum',
            'gtin': 'string',
            'image_url': 'Object',
            'inventory': 'unsigned int',
            'ios_app_name': 'string',
            'ios_app_store_id': 'unsigned int',
            'ios_url': 'string',
            'ipad_app_name': 'string',
            'ipad_app_store_id': 'unsigned int',
            'ipad_url': 'string',
            'iphone_app_name': 'string',
            'iphone_app_store_id': 'unsigned int',
            'iphone_url': 'string',
            'manufacturer_part_number': 'string',
            'material': 'string',
            'mobile_link': 'Object',
            'name': 'string',
            'offer_price_amount': 'unsigned int',
            'offer_price_end_date': 'Object',
            'offer_price_start_date': 'Object',
            'ordering_index': 'unsigned int',
            'pattern': 'string',
            'price': 'unsigned int',
            'product_type': 'string',
            'retailer_id': 'string',
            'retailer_product_group_id': 'string',
            'sale_price': 'unsigned int',
            'sale_price_end_date': 'datetime',
            'sale_price_start_date': 'datetime',
            'short_description': 'string',
            'size': 'string',
            'start_date': 'string',
            'url': 'Object',
            'visibility': 'visibility_enum',
            'windows_phone_app_id': 'string',
            'windows_phone_app_name': 'string',
            'windows_phone_url': 'string',
        }
        enums = {
            'availability_enum': ProductItem.Availability.__dict__.values(),
            'condition_enum': ProductItem.Condition.__dict__.values(),
            'gender_enum': ProductItem.Gender.__dict__.values(),
            'visibility_enum': ProductItem.Visibility.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/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()
Example #42
0
    def api_get(self,
                fields=None,
                params=None,
                batch=None,
                success=None,
                failure=None,
                pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
            api_utils.warning(
                '`success` and `failure` callback only work for batch call.')
        param_types = {
            'am_call_tags': 'map',
            'date_preset': 'date_preset_enum',
            'from_adtable': 'bool',
            'review_feedback_breakdown': 'bool',
            'time_range': 'Object',
        }
        enums = {
            'date_preset_enum': [
                'last_14d',
                'last_28d',
                'last_30d',
                'last_3d',
                'last_7d',
                'last_90d',
                'last_month',
                'last_quarter',
                'last_week_mon_sun',
                'last_week_sun_sat',
                'last_year',
                'lifetime',
                'this_month',
                'this_quarter',
                'this_week_mon_today',
                'this_week_sun_today',
                'this_year',
                'today',
                'yesterday',
            ],
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='GET',
            endpoint='/',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=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, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
    def remote_update(
        self,
        batch=None,
        failure=None,
        files=None,
        params=None,
        success=None,
        api_version=None,
    ):
        """Updates the object by calling the API with only the changes recorded.
        Args:
            batch (optional): A FacebookAdsApiBatch object. If specified,
                the call will be added to the batch.
            params (optional): A mapping of request parameters where a key
                is the parameter name and its value is a string or an object
                which can be JSON-encoded.
            files (optional): An optional mapping of file names to binary open
                file objects. These files will be attached to the request.
            success (optional): A callback function which will be called with
                the FacebookResponse of this call if the call succeeded.
            failure (optional): A callback function which will be called with
                the FacebookResponse of this call if the call failed.
        Returns:
            self if not a batch call.
            the return value of batch.add if a batch call.
        """
        params = {} if not params else params.copy()
        params.update(self.export_changed_data())
        self._set_data(params)
        if hasattr(self, 'api_update'):
            request = self.api_update(pending=True)
        else:
            request = FacebookRequest(
                node_id=self.get_id_assured(),
                method='POST',
                endpoint='/',
                api=self._api,
                target_class=self.__class__,
                response_parser=ObjectParser(
                    reuse_object=self
                ),
            )
        request.add_params(params)
        request.add_files(files)

        if batch is not None:
            def callback_success(response):
                self._clear_history()

                if success:
                    success(response)

            def callback_failure(response):
                if failure:
                    failure(response)

            batch_call = batch.add_request(
                request=request,
                success=callback_success,
                failure=callback_failure,
            )
            return batch_call
        else:
            request.execute()
            self._clear_history()

            return self
Example #44
0
    def create_video(self,
                     fields=None,
                     params=None,
                     batch=None,
                     pending=False):
        param_types = {
            'audio_story_wave_animation_handle': 'string',
            'content_category': 'content_category_enum',
            'description': 'string',
            'embeddable': 'bool',
            'end_offset': 'unsigned int',
            'file_size': 'unsigned int',
            'file_url': 'string',
            'fisheye_video_cropped': 'bool',
            'fov': 'unsigned int',
            'front_z_rotation': 'float',
            'guide': 'list<list<unsigned int>>',
            'guide_enabled': 'bool',
            'initial_heading': 'unsigned int',
            'initial_pitch': 'unsigned int',
            'original_fov': 'unsigned int',
            'original_projection_type': 'original_projection_type_enum',
            'react_mode_metadata': 'string',
            'referenced_sticker_id': 'string',
            'replace_video_id': 'string',
            'slideshow_spec': 'map',
            'source': 'string',
            'spherical': 'bool',
            'start_offset': 'unsigned int',
            'swap_mode': 'swap_mode_enum',
            'thumb': 'file',
            'title': 'string',
            'unpublished_content_type': 'unpublished_content_type_enum',
            'upload_phase': 'upload_phase_enum',
            'upload_session_id': 'string',
            'video_file_chunk': 'string',
            'xpost_everstore_handle': 'string',
        }
        enums = {
            'content_category_enum': [
                'BEAUTY_FASHION',
                'BUSINESS',
                'CARS_TRUCKS',
                'COMEDY',
                'CUTE_ANIMALS',
                'ENTERTAINMENT',
                'FAMILY',
                'FOOD_HEALTH',
                'HOME',
                'LIFESTYLE',
                'MUSIC',
                'NEWS',
                'POLITICS',
                'SCIENCE',
                'SPORTS',
                'TECHNOLOGY',
                'VIDEO_GAMING',
                'OTHER',
            ],
            'original_projection_type_enum': [
                'equirectangular',
                'cubemap',
                'equiangular_cubemap',
                'half_equirectangular',
            ],
            'swap_mode_enum': [
                'replace',
            ],
            'unpublished_content_type_enum': [
                'SCHEDULED',
                'DRAFT',
                'ADS_POST',
                'INLINE_CREATED',
                'PUBLISHED',
            ],
            'upload_phase_enum': [
                'start',
                'transfer',
                'finish',
                'cancel',
            ],
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/videos',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=AbstractCrudObject,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=AbstractCrudObject,
                                         api=self._api),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
Example #45
0
    def create_live_video(self,
                          fields=None,
                          params=None,
                          batch=None,
                          success=None,
                          failure=None,
                          pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
            api_utils.warning(
                '`success` and `failure` callback only work for batch call.')
        from facebook_business.adobjects.livevideo import LiveVideo
        param_types = {
            'attribution_app_id': 'string',
            'content_tags': 'list<string>',
            'description': 'string',
            'encoding_settings': 'string',
            'fisheye_video_cropped': 'bool',
            'front_z_rotation': 'float',
            'is_audio_only': 'bool',
            'is_spherical': 'bool',
            'live_encoders': 'list<string>',
            'original_fov': 'unsigned int',
            'planned_start_time': 'int',
            'privacy': 'string',
            'projection': 'projection_enum',
            'published': 'bool',
            'save_vod': 'bool',
            'schedule_custom_profile_image': 'file',
            'spatial_audio_format': 'spatial_audio_format_enum',
            'status': 'status_enum',
            'stereoscopic_mode': 'stereoscopic_mode_enum',
            'stop_on_delete_stream': 'bool',
            'stream_type': 'stream_type_enum',
            'title': 'string',
        }
        enums = {
            'projection_enum':
            LiveVideo.Projection.__dict__.values(),
            'spatial_audio_format_enum':
            LiveVideo.SpatialAudioFormat.__dict__.values(),
            'status_enum':
            LiveVideo.Status.__dict__.values(),
            'stereoscopic_mode_enum':
            LiveVideo.StereoscopicMode.__dict__.values(),
            'stream_type_enum':
            LiveVideo.StreamType.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/live_videos',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=LiveVideo,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=LiveVideo,
                                         api=self._api),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
Example #46
0
    def api_update(self, fields=None, params=None, batch=None, pending=False):
        param_types = {
            'account_id': 'string',
            'ad_keywords': 'Object',
            'adlabels': 'list<Object>',
            'bid_amount': 'int',
            'bid_adjustments': 'Object',
            'bid_constraints': 'Object',
            'bid_strategy': 'bid_strategy_enum',
            'billing_event': 'billing_event_enum',
            'campaign_spec': 'Object',
            'adset_schedule': 'list<Object>',
            'status': 'status_enum',
            'creative_sequence': 'list<string>',
            'daily_budget': 'unsigned int',
            'daily_imps': 'unsigned int',
            'daily_min_spend_target': 'unsigned int',
            'daily_spend_cap': 'unsigned int',
            'date_format': 'string',
            'destination_type': 'destination_type_enum',
            'end_time': 'datetime',
            'execution_options': 'list<execution_options_enum>',
            'frequency_cap': 'unsigned int',
            'frequency_cap_reset_period': 'unsigned int',
            'is_autobid': 'bool',
            'is_average_price_pacing': 'bool',
            'lifetime_budget': 'unsigned int',
            'lifetime_frequency_cap': 'unsigned int',
            'lifetime_imps': 'unsigned int',
            'lifetime_min_spend_target': 'unsigned int',
            'lifetime_spend_cap': 'unsigned int',
            'name': 'string',
            'optimization_goal': 'optimization_goal_enum',
            'pacing_type': 'list<string>',
            'promoted_object': 'Object',
            'rb_prediction_id': 'string',
            'rf_prediction_id': 'string',
            'start_time': 'datetime',
            'targeting': 'Targeting',
            'time_based_ad_rotation_id_blocks': 'list<list<unsigned int>>',
            'time_based_ad_rotation_intervals': 'list<unsigned int>',
            'time_start': 'datetime',
            'time_stop': 'datetime',
            'upstream_events': 'map',
            'full_funnel_exploration_mode':
            'full_funnel_exploration_mode_enum',
            'attribution_spec': 'list<map>',
        }
        enums = {
            'bid_strategy_enum':
            AdSet.BidStrategy.__dict__.values(),
            'billing_event_enum':
            AdSet.BillingEvent.__dict__.values(),
            'status_enum':
            AdSet.Status.__dict__.values(),
            'destination_type_enum':
            AdSet.DestinationType.__dict__.values(),
            'execution_options_enum':
            AdSet.ExecutionOptions.__dict__.values(),
            'optimization_goal_enum':
            AdSet.OptimizationGoal.__dict__.values(),
            'full_funnel_exploration_mode_enum':
            AdSet.FullFunnelExplorationMode.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=AdSet,
            api_type='NODE',
            response_parser=ObjectParser(reuse_object=self),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
    def api_update(self,
                   fields=None,
                   params=None,
                   batch=None,
                   success=None,
                   failure=None,
                   pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
            api_utils.warning(
                '`success` and `failure` callback only work for batch call.')
        param_types = {
            'account_id': 'string',
            'adlabels': 'list<Object>',
            'adset_schedule': 'list<Object>',
            'attribution_spec': 'list<map>',
            'bid_adjustments': 'Object',
            'bid_amount': 'int',
            'bid_constraints': 'map<string, Object>',
            'bid_strategy': 'bid_strategy_enum',
            'billing_event': 'billing_event_enum',
            'campaign_spec': 'Object',
            'creative_sequence': 'list<string>',
            'daily_budget': 'unsigned int',
            'daily_imps': 'unsigned int',
            'daily_min_spend_target': 'unsigned int',
            'daily_spend_cap': 'unsigned int',
            'date_format': 'string',
            'destination_type': 'destination_type_enum',
            'end_time': 'datetime',
            'execution_options': 'list<execution_options_enum>',
            'full_funnel_exploration_mode':
            'full_funnel_exploration_mode_enum',
            'lifetime_budget': 'unsigned int',
            'lifetime_imps': 'unsigned int',
            'lifetime_min_spend_target': 'unsigned int',
            'lifetime_spend_cap': 'unsigned int',
            'name': 'string',
            'optimization_goal': 'optimization_goal_enum',
            'optimization_sub_event': 'optimization_sub_event_enum',
            'pacing_type': 'list<string>',
            'promoted_object': 'Object',
            'rb_prediction_id': 'string',
            'rf_prediction_id': 'string',
            'start_time': 'datetime',
            'status': 'status_enum',
            'targeting': 'Targeting',
            'time_based_ad_rotation_id_blocks': 'list<list<unsigned int>>',
            'time_based_ad_rotation_intervals': 'list<unsigned int>',
            'time_start': 'datetime',
            'time_stop': 'datetime',
            'tune_for_category': 'tune_for_category_enum',
            'upstream_events': 'map',
        }
        enums = {
            'bid_strategy_enum':
            AdSet.BidStrategy.__dict__.values(),
            'billing_event_enum':
            AdSet.BillingEvent.__dict__.values(),
            'destination_type_enum':
            AdSet.DestinationType.__dict__.values(),
            'execution_options_enum':
            AdSet.ExecutionOptions.__dict__.values(),
            'full_funnel_exploration_mode_enum':
            AdSet.FullFunnelExplorationMode.__dict__.values(),
            'optimization_goal_enum':
            AdSet.OptimizationGoal.__dict__.values(),
            'optimization_sub_event_enum':
            AdSet.OptimizationSubEvent.__dict__.values(),
            'status_enum':
            AdSet.Status.__dict__.values(),
            'tune_for_category_enum':
            AdSet.TuneForCategory.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=AdSet,
            api_type='NODE',
            response_parser=ObjectParser(reuse_object=self),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
    def remote_create(
        self,
        batch=None,
        failure=None,
        files=None,
        params=None,
        success=None,
        api_version=None,
    ):
        """Creates the object by calling the API.
        Args:
            batch (optional): A FacebookAdsApiBatch object. If specified,
                the call will be added to the batch.
            params (optional): A mapping of request parameters where a key
                is the parameter name and its value is a string or an object
                which can be JSON-encoded.
            files (optional): An optional mapping of file names to binary open
                file objects. These files will be attached to the request.
            success (optional): A callback function which will be called with
                the FacebookResponse of this call if the call succeeded.
            failure (optional): A callback function which will be called with
                the FacebookResponse of this call if the call failed.
        Returns:
            self if not a batch call.
            the return value of batch.add if a batch call.
        """
        if self.get_id():
            raise FacebookBadObjectError(
                "This %s object was already created."
                % self.__class__.__name__,
            )
        if not 'get_endpoint' in dir(self):
            raise TypeError('Cannot create object of type %s.'
                            % self.__class__.__name__)

        params = {} if not params else params.copy()
        params.update(self.export_all_data())
        request = None
        if hasattr(self, 'api_create'):
            request = self.api_create(self.get_parent_id_assured(), pending=True)
        else:
            request = FacebookRequest(
                node_id=self.get_parent_id_assured(),
                method='POST',
                endpoint=self.get_endpoint(),
                api=self._api,
                target_class=self.__class__,
                response_parser=ObjectParser(
                    reuse_object=self
                ),
            )
        request.add_params(params)
        request.add_files(files)

        if batch is not None:

            def callback_success(response):
                self._set_data(response.json())
                self._clear_history()

                if success:
                    success(response)

            def callback_failure(response):
                if failure:
                    failure(response)

            return batch.add_request(
                request=request,
                success=callback_success,
                failure=callback_failure,
            )
        else:
            response = request.execute()
            self._set_data(response._json)
            self._clear_history()

            return self
Example #49
0
    def api_update(self,
                   fields=None,
                   params=None,
                   batch=None,
                   success=None,
                   failure=None,
                   pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
            api_utils.warning(
                '`success` and `failure` callback only work for batch call.')
        param_types = {
            'address': 'map',
            'applinks': 'Object',
            'availability': 'availability_enum',
            'body_style': 'body_style_enum',
            'condition': 'condition_enum',
            'currency': 'string',
            'date_first_on_lot': 'string',
            'dealer_id': 'string',
            'dealer_name': 'string',
            'dealer_phone': 'string',
            'description': 'string',
            'drivetrain': 'drivetrain_enum',
            'exterior_color': 'string',
            'fb_page_id': 'string',
            'fuel_type': 'fuel_type_enum',
            'images': 'list<Object>',
            'interior_color': 'string',
            'make': 'string',
            'mileage': 'map',
            'model': 'string',
            'price': 'unsigned int',
            'state_of_vehicle': 'state_of_vehicle_enum',
            'title': 'string',
            'transmission': 'transmission_enum',
            'trim': 'string',
            'url': 'string',
            'vehicle_type': 'vehicle_type_enum',
            'vin': 'string',
            'year': 'unsigned int',
        }
        enums = {
            'availability_enum': Vehicle.Availability.__dict__.values(),
            'body_style_enum': Vehicle.BodyStyle.__dict__.values(),
            'condition_enum': Vehicle.Condition.__dict__.values(),
            'drivetrain_enum': Vehicle.Drivetrain.__dict__.values(),
            'fuel_type_enum': Vehicle.FuelType.__dict__.values(),
            'state_of_vehicle_enum': Vehicle.StateOfVehicle.__dict__.values(),
            'transmission_enum': Vehicle.Transmission.__dict__.values(),
            'vehicle_type_enum': Vehicle.VehicleType.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=Vehicle,
            api_type='NODE',
            response_parser=ObjectParser(reuse_object=self),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
    def api_update(self, fields=None, params=None, batch=None, pending=False):
        param_types = {
            'content_tags': 'list<string>',
            'privacy': 'Object',
            'title': 'string',
            'description': 'string',
            'embeddable': 'bool',
            'disturbing': 'bool',
            'place': 'Object',
            'published': 'bool',
            'status': 'status_enum',
            'end_live_video': 'bool',
            'targeting': 'Object',
            'tags': 'list<int>',
            'og_phrase': 'string',
            'og_icon_id': 'string',
            'sponsor_id': 'string',
            'direct_share_status': 'unsigned int',
            'sponsor_relationship': 'unsigned int',
            'planned_start_time': 'int',
            'stream_type': 'stream_type_enum',
            'attribution_app_id': 'string',
            'attribution_app_metadata': 'string',
            'custom_labels': 'list<string>',
            'commercial_break_durations': 'list<unsigned int>',
            'is_audio_only': 'bool',
            'is_manual_mode': 'bool',
            'schedule_custom_profile_image': 'file',
            'schedule_feed_background_image': 'file',
            'product_items': 'list<string>',
            'ad_break_intent': 'bool',
            'ad_break_start_now': 'bool',
            'ad_break_drop_live_stream': 'bool',
            'ad_break_time_offset': 'float',
            'ad_break_encoder_drops_live_stream': 'bool',
            'ad_break_duration': 'unsigned int',
            'live_encoders': 'list<string>',
            'live_comment_moderation_setting':
            'list<live_comment_moderation_setting_enum>',
            'crossposting_actions': 'list<map>',
            'allow_bm_crossposting': 'bool',
        }
        enums = {
            'status_enum':
            LiveVideo.Status.__dict__.values(),
            'stream_type_enum':
            LiveVideo.StreamType.__dict__.values(),
            'live_comment_moderation_setting_enum':
            LiveVideo.LiveCommentModerationSetting.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=LiveVideo,
            api_type='NODE',
            response_parser=ObjectParser(reuse_object=self),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
Example #51
0
    def api_update(self,
                   fields=None,
                   params=None,
                   batch=None,
                   success=None,
                   failure=None,
                   pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
            api_utils.warning(
                '`success` and `failure` callback only work for batch call.')
        param_types = {
            'accountID': 'string',
            'additionalMetadata': 'string',
            'allowed_domains': 'list<string>',
            'claim_objective': 'claim_objective_enum',
            'content_type': 'content_type_enum',
            'countries': 'string',
            'customer_file_source': 'customer_file_source_enum',
            'description': 'string',
            'details': 'string',
            'enable_fetch_or_create': 'bool',
            'event_source_group': 'string',
            'event_sources': 'list<map>',
            'exclusions': 'list<Object>',
            'expectedSize': 'unsigned int',
            'gender': 'string',
            'inclusions': 'list<Object>',
            'isPrivate': 'bool',
            'is_household': 'bool',
            'is_household_exclusion': 'bool',
            'lookalike_spec': 'string',
            'maxAge': 'unsigned int',
            'minAge': 'unsigned int',
            'name': 'string',
            'opt_out_link': 'string',
            'parent_audience_id': 'unsigned int',
            'partnerID': 'string',
            'partner_reference_key': 'string',
            'product_set_id': 'string',
            'retention_days': 'unsigned int',
            'rev_share_policy_id': 'unsigned int',
            'rule': 'string',
            'rule_aggregation': 'string',
            'seed_audience': 'unsigned int',
            'source': 'string',
            'study_spec': 'map',
            'tags': 'list<string>',
        }
        enums = {
            'claim_objective_enum':
            CustomAudience.ClaimObjective.__dict__.values(),
            'content_type_enum':
            CustomAudience.ContentType.__dict__.values(),
            'customer_file_source_enum':
            CustomAudience.CustomerFileSource.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=CustomAudience,
            api_type='NODE',
            response_parser=ObjectParser(reuse_object=self),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
Example #52
0
    def get_insights(self,
                     fields=None,
                     params=None,
                     is_async=False,
                     batch=None,
                     pending=False):
        from facebook_business.adobjects.adsinsights import AdsInsights
        if is_async:
            return self.get_insights_async(fields, params, batch, pending)
        param_types = {
            'action_attribution_windows':
            'list<action_attribution_windows_enum>',
            'action_breakdowns': 'list<action_breakdowns_enum>',
            'action_report_time': 'action_report_time_enum',
            'breakdowns': 'list<breakdowns_enum>',
            'date_preset': 'date_preset_enum',
            'default_summary': 'bool',
            'export_columns': 'list<string>',
            'export_format': 'string',
            'export_name': 'string',
            'fields': 'list<fields_enum>',
            'filtering': 'list<Object>',
            'level': 'level_enum',
            'product_id_limit': 'int',
            'sort': 'list<string>',
            'summary': 'list<summary_enum>',
            'summary_action_breakdowns':
            'list<summary_action_breakdowns_enum>',
            'time_increment': 'string',
            'time_range': 'Object',
            'time_ranges': 'list<Object>',
            'use_account_attribution_setting': 'bool',
        }
        enums = {
            'fields_enum':
            AdsInsights.Field.__dict__.values(),
            'action_attribution_windows_enum':
            AdsInsights.ActionAttributionWindows.__dict__.values(),
            'action_breakdowns_enum':
            AdsInsights.ActionBreakdowns.__dict__.values(),
            'action_report_time_enum':
            AdsInsights.ActionReportTime.__dict__.values(),
            'breakdowns_enum':
            AdsInsights.Breakdowns.__dict__.values(),
            'date_preset_enum':
            AdsInsights.DatePreset.__dict__.values(),
            'summary_enum':
            AdsInsights.Summary.__dict__.values(),
            'level_enum':
            AdsInsights.Level.__dict__.values(),
            'summary_action_breakdowns_enum':
            AdsInsights.SummaryActionBreakdowns.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='GET',
            endpoint='/insights',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=AdsInsights,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=AdsInsights,
                                         api=self._api),
            include_summary=False,
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
Example #53
0
    def create_feed(self,
                    fields=None,
                    params=None,
                    batch=None,
                    success=None,
                    failure=None,
                    pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
            api_utils.warning(
                '`success` and `failure` callback only work for batch call.')
        param_types = {
            'actions': 'Object',
            'adaptive_type': 'string',
            'album_id': 'string',
            'android_key_hash': 'string',
            'animated_effect_id': 'unsigned int',
            'application_id': 'string',
            'asked_fun_fact_prompt_id': 'unsigned int',
            'asset3d_id': 'unsigned int',
            'associated_id': 'string',
            'attach_place_suggestion': 'bool',
            'attached_media': 'list<Object>',
            'audience_exp': 'bool',
            'backdated_time': 'datetime',
            'backdated_time_granularity': 'backdated_time_granularity_enum',
            'call_to_action': 'Object',
            'caption': 'string',
            'checkin_entry_point': 'checkin_entry_point_enum',
            'child_attachments': 'list<Object>',
            'client_mutation_id': 'string',
            'composer_entry_picker': 'string',
            'composer_entry_point': 'string',
            'composer_entry_time': 'unsigned int',
            'composer_session_events_log': 'string',
            'composer_session_id': 'string',
            'composer_source_surface': 'string',
            'composer_type': 'string',
            'connection_class': 'string',
            'content_attachment': 'string',
            'coordinates': 'Object',
            'cta_link': 'string',
            'cta_type': 'string',
            'description': 'string',
            'direct_share_status': 'unsigned int',
            'expanded_height': 'unsigned int',
            'expanded_width': 'unsigned int',
            'feed_targeting': 'Object',
            'formatting': 'formatting_enum',
            'fun_fact_prompt_id': 'unsigned int',
            'fun_fact_toastee_id': 'unsigned int',
            'has_nickname': 'bool',
            'height': 'unsigned int',
            'holiday_card': 'string',
            'home_checkin_city_id': 'Object',
            'image_crops': 'map',
            'implicit_with_tags': 'list<int>',
            'instant_game_entry_point_data': 'string',
            'ios_bundle_id': 'string',
            'is_backout_draft': 'bool',
            'is_boost_intended': 'bool',
            'is_explicit_location': 'bool',
            'is_explicit_share': 'bool',
            'is_group_linking_post': 'bool',
            'is_photo_container': 'bool',
            'link': 'string',
            'location_source_id': 'string',
            'manual_privacy': 'bool',
            'message': 'string',
            'multi_share_end_card': 'bool',
            'multi_share_optimized': 'bool',
            'name': 'string',
            'nectar_module': 'string',
            'object_attachment': 'string',
            'offer_like_post_id': 'unsigned int',
            'og_action_type_id': 'string',
            'og_hide_object_attachment': 'bool',
            'og_icon_id': 'string',
            'og_object_id': 'string',
            'og_phrase': 'string',
            'og_set_profile_badge': 'bool',
            'og_suggestion_mechanism': 'string',
            'page_recommendation': 'string',
            'picture': 'string',
            'place': 'Object',
            'place_attachment_setting': 'place_attachment_setting_enum',
            'place_list': 'string',
            'place_list_data': 'list',
            'post_surfaces_blacklist': 'list<post_surfaces_blacklist_enum>',
            'posting_to_redspace': 'posting_to_redspace_enum',
            'privacy': 'string',
            'prompt_id': 'string',
            'prompt_tracking_string': 'string',
            'properties': 'Object',
            'proxied_app_id': 'string',
            'publish_event_id': 'unsigned int',
            'published': 'bool',
            'quote': 'string',
            'react_mode_metadata': 'string',
            'ref': 'list<string>',
            'referenceable_image_ids': 'list<string>',
            'referral_id': 'string',
            'sales_promo_id': 'unsigned int',
            'scheduled_publish_time': 'datetime',
            'source': 'string',
            'sponsor_id': 'string',
            'sponsor_relationship': 'unsigned int',
            'suggested_place_id': 'Object',
            'tags': 'list<int>',
            'target_surface': 'target_surface_enum',
            'targeting': 'Object',
            'text_format_metadata': 'string',
            'text_format_preset_id': 'string',
            'text_only_place': 'string',
            'throwback_camera_roll_media': 'string',
            'thumbnail': 'file',
            'time_since_original_post': 'unsigned int',
            'title': 'string',
            'tracking_info': 'string',
            'unpublished_content_type': 'unpublished_content_type_enum',
            'user_selected_tags': 'bool',
            'video_start_time_ms': 'unsigned int',
            'viewer_coordinates': 'Object',
            'width': 'unsigned int',
        }
        enums = {
            'backdated_time_granularity_enum': [
                'day',
                'hour',
                'min',
                'month',
                'none',
                'year',
            ],
            'checkin_entry_point_enum': [
                'BRANDING_CHECKIN',
                'BRANDING_OTHER',
                'BRANDING_PHOTO',
                'BRANDING_STATUS',
            ],
            'formatting_enum': [
                'MARKDOWN',
                'PLAINTEXT',
            ],
            'place_attachment_setting_enum': [
                '1',
                '2',
            ],
            'post_surfaces_blacklist_enum': [
                '1',
                '2',
                '3',
                '4',
                '5',
            ],
            'posting_to_redspace_enum': [
                'disabled',
                'enabled',
            ],
            'target_surface_enum': [
                'STORY',
                'TIMELINE',
            ],
            'unpublished_content_type_enum': [
                'ADS_POST',
                'DRAFT',
                'INLINE_CREATED',
                'PUBLISHED',
                'REVIEWABLE_BRANDED_CONTENT',
                'SCHEDULED',
                'SCHEDULED_RECURRING',
            ],
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/feed',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=AbstractCrudObject,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=AbstractCrudObject,
                                         api=self._api),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
Example #54
0
    def create_promotion(self,
                         fields=None,
                         params=None,
                         batch=None,
                         pending=False):
        param_types = {
            'budget': 'unsigned int',
            'currency': 'string',
            'ad_account_id': 'string',
            'audience': 'audience_enum',
            'targeting': 'Targeting',
            'start_time': 'unsigned int',
            'stop_time': 'unsigned int',
            'ad_conversion_pixel_id': 'unsigned int',
            'placement': 'string',
            'flow_id': 'string',
            'audience_id': 'string',
            'bid_amount': 'unsigned int',
            'cta_type': 'cta_type_enum',
        }
        enums = {
            'audience_enum': [
                'GROUPER',
                'NCPP',
                'CUSTOM_AUDIENCE',
                'LOOKALIKE',
                'FANS',
                'LOCAL',
                'IG_PROMOTED_POST_AUTO',
                'SAVED_AUDIENCE',
                'EVENT_ENGAGEMENT',
                'DISTRICT',
                'SMART_AUDIENCE',
                'CREATE_NEW',
                'AUTO_LOOKALIKE',
                'MULT_CUSTOM_AUDIENCES',
                'EVENT_CUSTOM_AUDIENCES',
                'AUTO_PAGE_LOOKALIKE',
            ],
            'cta_type_enum': [
                'OPEN_LINK',
                'LIKE_PAGE',
                'SHOP_NOW',
                'PLAY_GAME',
                'INSTALL_APP',
                'USE_APP',
                'CALL',
                'CALL_ME',
                'INSTALL_MOBILE_APP',
                'USE_MOBILE_APP',
                'MOBILE_DOWNLOAD',
                'BOOK_TRAVEL',
                'LISTEN_MUSIC',
                'WATCH_VIDEO',
                'LEARN_MORE',
                'SIGN_UP',
                'DOWNLOAD',
                'WATCH_MORE',
                'NO_BUTTON',
                'VISIT_PAGES_FEED',
                'APPLY_NOW',
                'BUY_NOW',
                'GET_OFFER',
                'GET_OFFER_VIEW',
                'BUY_TICKETS',
                'UPDATE_APP',
                'GET_DIRECTIONS',
                'BUY',
                'MESSAGE_PAGE',
                'DONATE',
                'SUBSCRIBE',
                'SAY_THANKS',
                'SELL_NOW',
                'SHARE',
                'DONATE_NOW',
                'GET_QUOTE',
                'CONTACT_US',
                'ORDER_NOW',
                'ADD_TO_CART',
                'VIDEO_ANNOTATION',
                'MOMENTS',
                'RECORD_NOW',
                'GET_SHOWTIMES',
                'LISTEN_NOW',
                'WOODHENGE_SUPPORT',
                'EVENT_RSVP',
                'WHATSAPP_MESSAGE',
                'FOLLOW_NEWS_STORYLINE',
                'SEE_MORE',
            ],
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/promotions',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=AbstractCrudObject,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=AbstractCrudObject,
                                         api=self._api),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
Example #55
0
    def create_telemetry(self,
                         fields=None,
                         params=None,
                         batch=None,
                         success=None,
                         failure=None,
                         pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
            api_utils.warning(
                '`success` and `failure` callback only work for batch call.')
        param_types = {
            'bitrate': 'unsigned int',
            'broadcast_id': 'string',
            'cpu_load_15m': 'float',
            'cpu_load_1m': 'float',
            'cpu_load_5m': 'float',
            'cpu_temperature': 'unsigned int',
            'cpu_usage': 'float',
            'framerate': 'float',
            'frames_dropped': 'float',
            'gpu_temperature': 'unsigned int',
            'gpu_usage': 'float',
            'last_audio_timecode': 'unsigned int',
            'last_video_keyframe_timecode': 'unsigned int',
            'last_video_timecode': 'unsigned int',
            'memory_usage': 'float',
            'network_latency': 'float',
            'network_rx_bandwidth': 'unsigned int',
            'network_rx_packets_dropped': 'float',
            'network_rx_packets_errors': 'float',
            'network_tx_bandwidth': 'unsigned int',
            'network_tx_packets_dropped': 'float',
            'network_tx_packets_errors': 'float',
            'process_uptime': 'unsigned int',
            'status': 'status_enum',
            'timestamp': 'unsigned int',
            'total_audio_frames_sent': 'unsigned int',
            'total_video_frames_sent': 'unsigned int',
            'total_video_keyframes_sent': 'unsigned int',
            'uptime': 'unsigned int',
        }
        enums = {
            'status_enum': LiveEncoder.Status.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/telemetry',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=LiveEncoder,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=LiveEncoder,
                                         api=self._api),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
Example #56
0
    def api_get(self, fields=None, params=None, batch=None, pending=False):
        param_types = {
            'country_code': 'string',
            'extra_data': 'string',
            'order_id': 'string',
            'payment_type': 'payment_type_enum',
            'receiver_id': 'Object',
            'session_id': 'string',
        }
        enums = {
            'payment_type_enum': [
                'PAYMENT_SETTINGS',
                'IG_PAYMENT_SETTINGS',
                'UNKNOWN',
                'MP_PAYMENT_SETTINGS',
                'IAP_INSTANT_GAME',
                'IAP_FAN_FUNDING',
                'IAP_GROUP_SUBSCRIPTION',
                'MOR_NONE',
                'MOR_ADS_CONSENT',
                'MOR_ADS_INVOICE',
                'MOR_DONATIONS',
                'MOR_DONATIONS_MATCHING_CONFIRMATION',
                'MOR_DONATIONS_MATCHING_PLEDGE',
                'MOR_OCULUS_CV1',
                'MOR_OCULUS_LAUNCH_V1',
                'MOR_OCULUS_LAUNCH_V2',
                'MOR_OZONE',
                'MOR_OPEN_GRAPH_PRODUCT',
                'MOR_MESSENGER_COMMERCE',
                'MOR_P2P_TRANSFER',
                'MOR_DUMMY_FIRST_PARTY',
                'MOR_DUMMY_THIRD_PARTY',
                'MOR_GIFTS',
                'MOR_BILL',
                'MOR_AIRMAIL',
                'MOR_EVENT_TICKETING',
                'MOR_PAYMENT_LITE',
                'MOR_MESSENGER_API_FEE',
                'MOR_WORKPLACE_USAGE',
                'MOR_FACEBOOK_SHOP',
                'MOR_FAN_FUNDING',
                'MOR_GAME_TIPPING_TOKEN',
                'MOR_INSTANT_GAMES',
                'MOR_BLUEBIRD',
                'MOR_GROUP_SUBSCRIPTION',
                'NMOR_UNKNOWN',
                'NMOR_NONE',
                'NMOR_PAGES_COMMERCE',
                'NMOR_COMPONENT_FLOW',
                'NMOR_BUSINESS_PLATFORM_COMMERCE',
                'NMOR_SYNCHRONOUS_COMPONENT_FLOW',
                'NMOR_EVENT_TICKETING',
                'NMOR_PLATFORM_SELF_SERVE',
                'NMOR_MESSENGER_PLATFORM',
                'NMOR_MESSENGER_OMNIM',
                'NMOR_BILLING_ENGINE',
                'NMOR_TIP_JAR',
                'NMOR_INSTANT_EXPERIENCES',
                'NMOR_CHECKOUT_EXPERIENCES',
                'NMOR_BUY_ON_FACEBOOK',
                'NMOR_PAYMENT_APP',
                'NMOR_DONATION_P4P',
                'NMOR_WHATSAPP_P2P',
                'NMOR_P2P',
                'NMOR_MOBILE_TOP_UP',
                'NMOR_MFS',
                'NMOR_SHIPPING_LABEL',
                'NMOR_MARKETPLACE_DROPOFF',
                'NMOR_PAGES_SOLUTION',
                'NMOR_BLACKBAUD_RWR_DONATION',
                'NMOR_MARKETPLACE_SHIPPING',
                'NMOR_DUMMY',
                'NMOR_PPGF_DONATION',
                'NMOR_ADVERTISER_SUBSCRIPTION',
                'NMOR_WHATSAPP_P2M',
                'NMOR_MOVIE_TICKETING',
                'IG_NMOR_P2B',
                'NMOR_INSTAGRAM_P2B',
            ],
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='GET',
            endpoint='/',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=UserPaymentModulesOptions,
            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_photo(self, fields=None, params=None, batch=None, success=None, failure=None, pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
          api_utils.warning('`success` and `failure` callback only work for batch call.')
        from facebook_business.adobjects.photo import Photo
        param_types = {
            'aid': 'string',
            'allow_spherical_photo': 'bool',
            'alt_text_custom': 'string',
            'android_key_hash': 'string',
            'application_id': 'string',
            'attempt': 'unsigned int',
            'audience_exp': 'bool',
            'backdated_time': 'datetime',
            'backdated_time_granularity': 'backdated_time_granularity_enum',
            'caption': 'string',
            'composer_session_id': 'string',
            'direct_share_status': 'unsigned int',
            'feed_targeting': 'Object',
            'filter_type': 'unsigned int',
            'full_res_is_coming_later': 'bool',
            'initial_view_heading_override_degrees': 'unsigned int',
            'initial_view_pitch_override_degrees': 'unsigned int',
            'initial_view_vertical_fov_override_degrees': 'unsigned int',
            'ios_bundle_id': 'string',
            'is_explicit_location': 'bool',
            'is_explicit_place': 'bool',
            'is_visual_search': 'bool',
            'manual_privacy': 'bool',
            'message': 'string',
            'name': 'string',
            'no_story': 'bool',
            'offline_id': 'unsigned int',
            'og_action_type_id': 'string',
            'og_icon_id': 'string',
            'og_object_id': 'string',
            'og_phrase': 'string',
            'og_set_profile_badge': 'bool',
            'og_suggestion_mechanism': 'string',
            'place': 'Object',
            'privacy': 'string',
            'profile_id': 'int',
            'proxied_app_id': 'string',
            'published': 'bool',
            'qn': 'string',
            'scheduled_publish_time': 'unsigned int',
            'spherical_metadata': 'map',
            'sponsor_id': 'string',
            'sponsor_relationship': 'unsigned int',
            'tags': 'list<Object>',
            'target_id': 'int',
            'targeting': 'Object',
            'time_since_original_post': 'unsigned int',
            'uid': 'int',
            'unpublished_content_type': 'unpublished_content_type_enum',
            'url': 'string',
            'user_selected_tags': 'bool',
            'vault_image_id': 'string',
        }
        enums = {
            'backdated_time_granularity_enum': Photo.BackdatedTimeGranularity.__dict__.values(),
            'unpublished_content_type_enum': Photo.UnpublishedContentType.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/photos',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=Photo,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=Photo, api=self._api),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
    def api_update(self,
                   fields=None,
                   params=None,
                   batch=None,
                   success=None,
                   failure=None,
                   pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
            api_utils.warning(
                '`success` and `failure` callback only work for batch call.')
        param_types = {
            'adlabels': 'list<Object>',
            'adset_bid_amounts': 'map',
            'adset_budgets': 'list<map>',
            'bid_strategy': 'bid_strategy_enum',
            'budget_rebalance_flag': 'bool',
            'daily_budget': 'unsigned int',
            'execution_options': 'list<execution_options_enum>',
            'iterative_split_test_configs': 'list<Object>',
            'lifetime_budget': 'unsigned int',
            'name': 'string',
            'objective': 'objective_enum',
            'pacing_type': 'list<string>',
            'promoted_object': 'Object',
            'special_ad_category': 'special_ad_category_enum',
            'spend_cap': 'unsigned int',
            'status': 'status_enum',
            'upstream_events': 'map',
        }
        enums = {
            'bid_strategy_enum':
            Campaign.BidStrategy.__dict__.values(),
            'execution_options_enum':
            Campaign.ExecutionOptions.__dict__.values(),
            'objective_enum':
            Campaign.Objective.__dict__.values(),
            'special_ad_category_enum':
            Campaign.SpecialAdCategory.__dict__.values(),
            'status_enum':
            Campaign.Status.__dict__.values(),
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=Campaign,
            api_type='NODE',
            response_parser=ObjectParser(reuse_object=self),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()
Example #59
0
    def create_message(self,
                       fields=None,
                       params=None,
                       batch=None,
                       pending=False):
        param_types = {
            'aloha_action': 'string',
            'android_key_hash': 'string',
            'applied_art_data': 'Object',
            'associated_object_id': 'Object',
            'attribution_app_id': 'string',
            'attribution_app_metadata': 'string',
            'audio_duration': 'int',
            'audio_type': 'audio_type_enum',
            'body': 'string',
            'broadcast_recipients': 'map',
            'client_tags': 'map',
            'coordinates': 'Object',
            'copy_attachment': 'string',
            'copy_message': 'string',
            'customizations': 'map',
            'entry_point': 'string',
            'external_attachment_url': 'string',
            'image_type': 'image_type_enum',
            'ios_bundle_id': 'string',
            'is_broadcast': 'bool',
            'is_montage': 'bool',
            'is_voicemail': 'bool',
            'lightweight_action_attachment': 'Object',
            'link': 'string',
            'live_location_attachment': 'Object',
            'location_attachment': 'Object',
            'log_info': 'Object',
            'mark_read_watermark_timestamp': 'int',
            'media': 'list<string>',
            'message_source_data': 'Object',
            'montage_frame_style': 'montage_frame_style_enum',
            'montage_business_platform_data': 'map',
            'montage_overlays': 'list<map>',
            'montage_supported_features':
            'list<montage_supported_features_enum>',
            'montage_mentions': 'map',
            'montage_reply_data': 'Object',
            'object_attachment': 'string',
            'offline_threading_id': 'string',
            'platform_xmd': 'string',
            'prng': 'Object',
            'proxied_app_id': 'string',
            'recipients': 'Object',
            'replace_message_id': 'string',
            'replied_to_message_id': 'string',
            'selected_cta_token': 'string',
            'shareable_attachment': 'Object',
            'shown_cta_tokens': 'list<string>',
            'skip_android_hash_check': 'bool',
            'story_id': 'Object',
            'tags': 'list<string>',
            'tid': 'string',
            'tracking': 'string',
            'ttl': 'unsigned int',
            'use_existing_group': 'bool',
            'video_thumbnail': 'file',
            'video_type': 'video_type_enum',
            'message_attempt_id': 'string',
            'is_admin_model_v2_enabled': 'bool',
        }
        enums = {
            'audio_type_enum': [
                'FILE_ATTACHMENT',
                'VOICE_MESSAGE',
                'VOICE_MESSAGE_WITH_TRANSCRIPT',
            ],
            'image_type_enum': [
                'FILE_ATTACHMENT',
                'MESSENGER_CAM',
                'TRANSPARENT',
            ],
            'montage_frame_style_enum': [
                'no_border',
            ],
            'montage_supported_features_enum': [
                'LIGHTWEIGHT_REPLY',
                'SHOW_STORY_IN_MESSENGER_THREAD',
            ],
            'video_type_enum': [
                'FILE_ATTACHMENT',
                'RECORDED_VIDEO',
                'SPEAKING_STICKER',
                'RECORDED_STICKER',
                'VIDEO_MAIL',
            ],
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/messages',
            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()
Example #60
0
    def create_product(self,
                       fields=None,
                       params=None,
                       batch=None,
                       success=None,
                       failure=None,
                       pending=False):
        from facebook_business.utils import api_utils
        if batch is None and (success is not None or failure is not None):
            api_utils.warning(
                '`success` and `failure` callback only work for batch call.')
        param_types = {
            'additional_image_urls': 'list<string>',
            'additional_variant_attributes': 'map',
            'android_app_name': 'string',
            'android_class': 'string',
            'android_package': 'string',
            'android_url': 'string',
            'availability': 'availability_enum',
            'brand': 'string',
            'category': 'string',
            'checkout_url': 'string',
            'color': 'string',
            'commerce_tax_category': 'commerce_tax_category_enum',
            'condition': 'condition_enum',
            'currency': 'string',
            'custom_data': 'map',
            'custom_label_0': 'string',
            'custom_label_1': 'string',
            'custom_label_2': 'string',
            'custom_label_3': 'string',
            'custom_label_4': 'string',
            'description': 'string',
            'expiration_date': 'string',
            'fb_product_category': 'string',
            'gender': 'gender_enum',
            'gtin': 'string',
            'image_url': 'string',
            'inventory': 'unsigned int',
            'ios_app_name': 'string',
            'ios_app_store_id': 'unsigned int',
            'ios_url': 'string',
            'ipad_app_name': 'string',
            'ipad_app_store_id': 'unsigned int',
            'ipad_url': 'string',
            'iphone_app_name': 'string',
            'iphone_app_store_id': 'unsigned int',
            'iphone_url': 'string',
            'launch_date': 'string',
            'manufacturer_part_number': 'string',
            'marked_for_product_launch': 'marked_for_product_launch_enum',
            'material': 'string',
            'mobile_link': 'string',
            'name': 'string',
            'offer_price_amount': 'unsigned int',
            'offer_price_end_date': 'datetime',
            'offer_price_start_date': 'datetime',
            'ordering_index': 'unsigned int',
            'pattern': 'string',
            'price': 'unsigned int',
            'product_type': 'string',
            'quantity_to_sell_on_facebook': 'unsigned int',
            'retailer_id': 'string',
            'return_policy_days': 'unsigned int',
            'sale_price': 'unsigned int',
            'sale_price_end_date': 'datetime',
            'sale_price_start_date': 'datetime',
            'short_description': 'string',
            'size': 'string',
            'start_date': 'string',
            'url': 'string',
            'visibility': 'visibility_enum',
            'windows_phone_app_id': 'string',
            'windows_phone_app_name': 'string',
            'windows_phone_url': 'string',
        }
        enums = {
            'availability_enum': [
                'available for order',
                'discontinued',
                'in stock',
                'out of stock',
                'pending',
                'preorder',
            ],
            'commerce_tax_category_enum': [
                'FB_ANIMAL',
                'FB_ANIMAL_SUPP',
                'FB_APRL',
                'FB_APRL_ACCESSORIES',
                'FB_APRL_ATHL_UNIF',
                'FB_APRL_CASES',
                'FB_APRL_CLOTHING',
                'FB_APRL_COSTUME',
                'FB_APRL_CSTM',
                'FB_APRL_FORMAL',
                'FB_APRL_HANDBAG',
                'FB_APRL_JEWELRY',
                'FB_APRL_SHOE',
                'FB_APRL_SHOE_ACC',
                'FB_APRL_SWIM',
                'FB_APRL_SWIM_CHIL',
                'FB_APRL_SWIM_CVR',
                'FB_ARTS',
                'FB_ARTS_HOBBY',
                'FB_ARTS_PARTY',
                'FB_ARTS_PARTY_GIFT_CARD',
                'FB_ARTS_TICKET',
                'FB_BABY',
                'FB_BABY_BATH',
                'FB_BABY_BLANKET',
                'FB_BABY_DIAPER',
                'FB_BABY_GIFT_SET',
                'FB_BABY_HEALTH',
                'FB_BABY_NURSING',
                'FB_BABY_POTTY_TRN',
                'FB_BABY_SAFE',
                'FB_BABY_TOYS',
                'FB_BABY_TRANSPORT',
                'FB_BABY_TRANSPORT_ACC',
                'FB_BAGS',
                'FB_BAGS_BKPK',
                'FB_BAGS_BOXES',
                'FB_BAGS_BRFCS',
                'FB_BAGS_CSMT_BAG',
                'FB_BAGS_DFFL',
                'FB_BAGS_DIPR',
                'FB_BAGS_FNNY',
                'FB_BAGS_GRMT',
                'FB_BAGS_LUGG',
                'FB_BAGS_LUG_ACC',
                'FB_BAGS_MSGR',
                'FB_BAGS_TOTE',
                'FB_BAGS_TRN_CAS',
                'FB_BLDG',
                'FB_BLDG_ACC',
                'FB_BLDG_CNSMB',
                'FB_BLDG_FENCE',
                'FB_BLDG_FUEL_TNK',
                'FB_BLDG_HT_VNT',
                'FB_BLDG_LOCK',
                'FB_BLDG_MATRL',
                'FB_BLDG_PLMB',
                'FB_BLDG_PUMP',
                'FB_BLDG_PWRS',
                'FB_BLDG_STR_TANK',
                'FB_BLDG_S_ENG',
                'FB_BLDG_TL_ACC',
                'FB_BLDG_TOOL',
                'FB_BUSIND',
                'FB_BUSIND_ADVERTISING',
                'FB_BUSIND_AGRICULTURE',
                'FB_BUSIND_AUTOMATION',
                'FB_BUSIND_HEAVY_MACH',
                'FB_BUSIND_LAB',
                'FB_BUSIND_MEDICAL',
                'FB_BUSIND_RETAIL',
                'FB_BUSIND_SANITARY_CT',
                'FB_BUSIND_SIGN',
                'FB_BUSIND_STORAGE',
                'FB_BUSIND_STORAGE_ACC',
                'FB_BUSIND_WORK_GEAR',
                'FB_CAMERA_ACC',
                'FB_CAMERA_CAMERA',
                'FB_CAMERA_OPTIC',
                'FB_CAMERA_OPTICS',
                'FB_CAMERA_PHOTO',
                'FB_ELEC',
                'FB_ELEC_ACC',
                'FB_ELEC_ARCDADE',
                'FB_ELEC_AUDIO',
                'FB_ELEC_CIRCUIT',
                'FB_ELEC_COMM',
                'FB_ELEC_COMPUTER',
                'FB_ELEC_GPS_ACC',
                'FB_ELEC_GPS_NAV',
                'FB_ELEC_GPS_TRK',
                'FB_ELEC_MARINE',
                'FB_ELEC_NETWORK',
                'FB_ELEC_PART',
                'FB_ELEC_PRINT',
                'FB_ELEC_RADAR',
                'FB_ELEC_SPEED_RDR',
                'FB_ELEC_TOLL',
                'FB_ELEC_VIDEO',
                'FB_ELEC_VID_GM_ACC',
                'FB_ELEC_VID_GM_CNSL',
                'FB_FOOD',
                'FB_FURN',
                'FB_FURN_BABY',
                'FB_FURN_BENCH',
                'FB_FURN_CART',
                'FB_FURN_CHAIR',
                'FB_FURN_CHAIR_ACC',
                'FB_FURN_DIVIDE',
                'FB_FURN_DIVIDE_ACC',
                'FB_FURN_ENT_CTR',
                'FB_FURN_FUTN',
                'FB_FURN_FUTN_PAD',
                'FB_FURN_OFFICE',
                'FB_FURN_OFFICE_ACC',
                'FB_FURN_OTTO',
                'FB_FURN_OUTDOOR',
                'FB_FURN_OUTDOOR_ACC',
                'FB_FURN_SETS',
                'FB_FURN_SHELVE_ACC',
                'FB_FURN_SHLF',
                'FB_FURN_SOFA',
                'FB_FURN_SOFA_ACC',
                'FB_FURN_STORAGE',
                'FB_FURN_TABL',
                'FB_FURN_TABL_ACC',
                'FB_GENERIC_TAXABLE',
                'FB_HLTH',
                'FB_HLTH_HLTH',
                'FB_HLTH_JWL_CR',
                'FB_HLTH_LILP_BLM',
                'FB_HLTH_LTN_SPF',
                'FB_HLTH_PRSL_CR',
                'FB_HLTH_SKN_CR',
                'FB_HMGN',
                'FB_HMGN_BATH',
                'FB_HMGN_DCOR',
                'FB_HMGN_EMGY',
                'FB_HMGN_FPLC',
                'FB_HMGN_FPLC_ACC',
                'FB_HMGN_GS_SFT',
                'FB_HMGN_HS_ACC',
                'FB_HMGN_HS_APP',
                'FB_HMGN_HS_SPL',
                'FB_HMGN_KTCN',
                'FB_HMGN_LAWN',
                'FB_HMGN_LGHT',
                'FB_HMGN_LINN',
                'FB_HMGN_LT_ACC',
                'FB_HMGN_OTDR',
                'FB_HMGN_POOL',
                'FB_HMGN_SCTY',
                'FB_HMGN_SMK_ACC',
                'FB_HMGN_UMBR',
                'FB_HMGN_UMBR_ACC',
                'FB_MDIA',
                'FB_MDIA_BOOK',
                'FB_MDIA_DVDS',
                'FB_MDIA_MAG',
                'FB_MDIA_MANL',
                'FB_MDIA_MUSC',
                'FB_MDIA_PRJ_PLN',
                'FB_MDIA_SHT_MUS',
                'FB_OFFC',
                'FB_OFFC_BKAC',
                'FB_OFFC_CRTS',
                'FB_OFFC_DSKP',
                'FB_OFFC_EQIP',
                'FB_OFFC_FLNG',
                'FB_OFFC_GNRL',
                'FB_OFFC_INSTM',
                'FB_OFFC_LP_DSK',
                'FB_OFFC_MATS',
                'FB_OFFC_NM_PLT',
                'FB_OFFC_PPR_HNDL',
                'FB_OFFC_PRSNT_SPL',
                'FB_OFFC_SEALR',
                'FB_OFFC_SHIP_SPL',
                'FB_RLGN',
                'FB_RLGN_CMNY',
                'FB_RLGN_ITEM',
                'FB_RLGN_WEDD',
                'FB_SFTWR',
                'FB_SFWR_CMPTR',
                'FB_SFWR_DGTL_GD',
                'FB_SFWR_GAME',
                'FB_SHIPPING',
                'FB_SPOR',
                'FB_SPORT_ATHL',
                'FB_SPORT_ATHL_CLTH',
                'FB_SPORT_ATHL_SHOE',
                'FB_SPORT_ATHL_SPRT',
                'FB_SPORT_EXRCS',
                'FB_SPORT_INDR_GM',
                'FB_SPORT_OTDR_GM',
                'FB_TOYS',
                'FB_TOYS_EQIP',
                'FB_TOYS_GAME',
                'FB_TOYS_PZZL',
                'FB_TOYS_TMRS',
                'FB_TOYS_TOYS',
                'FB_VEHI',
                'FB_VEHI_PART',
            ],
            'condition_enum': [
                'cpo',
                'new',
                'open_box_new',
                'refurbished',
                'used',
                'used_fair',
                'used_good',
                'used_like_new',
            ],
            'gender_enum': [
                'female',
                'male',
                'unisex',
            ],
            'marked_for_product_launch_enum': [
                'default',
                'marked',
                'not_marked',
            ],
            'visibility_enum': [
                'published',
                'staging',
            ],
        }
        request = FacebookRequest(
            node_id=self['id'],
            method='POST',
            endpoint='/products',
            api=self._api,
            param_checker=TypeChecker(param_types, enums),
            target_class=AbstractCrudObject,
            api_type='EDGE',
            response_parser=ObjectParser(target_class=AbstractCrudObject,
                                         api=self._api),
        )
        request.add_params(params)
        request.add_fields(fields)

        if batch is not None:
            request.add_to_batch(batch, success=success, failure=failure)
            return request
        elif pending:
            return request
        else:
            self.assure_call()
            return request.execute()