def supplier_can_use_data(self):
     if self._core_customer:
         return resolve_boolean(
             self._core_customer.dp_supplier
         )
     else:
         if isinstance(self._supplier_can_use_data, bool):
             return self._supplier_can_use_data
         elif isinstance(self._supplier_can_use_data, basestring):
             return resolve_boolean(
                 self._supplier_can_use_data
             )

 def user_can_use_data(self):
     if self._core_customer:
         return resolve_boolean(
             self._core_customer.dp_user
         )
     else:
         if isinstance(self._user_can_use_data, bool):
             return self._user_can_use_data
         elif isinstance(self._user_can_use_data, six.string_types):
             return resolve_boolean(
                 self._user_can_use_data
             )

 def world_can_use_data(self):
     if self._core_customer:
         return resolve_boolean(
             self._core_customer.dp_world
         )
     else:
         if isinstance(self._world_can_use_data, bool):
             return self._world_can_use_data
         elif isinstance(self._world_can_use_data, basestring):
             return resolve_boolean(
                 self._world_can_use_data
             )

    def example_seats_are_real(self):
        """Boolean to indicate if the example_seats are actual seat numbers.

        If True, the seats in the example_seats list will be the seats that
        are reserved.
        """
        return resolve_boolean(self._core_price_band.example_seats_are_real)

    def need_departure_date(self):
        """Flag to indicate that a departure date is required.

        Value can be True/False (a departure date is/isn't required)
        or None (the data could not be retrieved/unknown).
        See the API documentation for more information about the
        'need_departure_date' flag.
        """

        if self._need_departure_date is None:
            need_departure_date = self._get_core_event_attr(
                'need_departure_date'
            )

            if need_departure_date:

                self._need_departure_date = resolve_boolean(
                    need_departure_date
                )

            else:
                self.get_performances()

        if self._need_departure_date:
            return self._need_departure_date
        else:
            return None

    def is_purchase_successful(self):
        """Boolean indicating if the bundle was purchased successfully

        Will return True if the purchase was successful,
        False if the purchase was not successful and
        None if no purchase was attempted.
        """
        is_success = None

        if self._core_bundle.purchase_result:

            is_success = resolve_boolean(self._core_bundle.purchase_result.success)

        return is_success

    def _build_reviews(self):
        self._critic_reviews = []
        self._user_reviews = []
        for r in self._get_core_event_attr('reviews'):

            is_user_bool = resolve_boolean(r.is_user_review)

            review = Review(
                core_review=r, is_user_review=is_user_bool
            )

            if is_user_bool:
                self._user_reviews.append(review)
            else:
                self._critic_reviews.append(review)

    def is_purchase_successful(self):
        """Check if the trolley was purchased successfully

        Will return True if the purchase was successful,
        False if the purchase was not successful and
        None if no purchase was attempted.
        """
        is_success = None

        if self._core_trolley.purchase_result:

            is_success = resolve_boolean(
                self._core_trolley.purchase_result.success
            )

        return is_success

    def delete(self):
        """Cancels this reservation, returns True if successful."""

        crypto_block = self._get_crypto_block_for_object(
            method_name='make_reservation',
            interface_object=self
        )

        resp_dict = self.get_core_api().release_reservation(
            crypto_block=crypto_block,
            upfront_data_token=self.settings['upfront_data_token'],
        )

        return resolve_boolean(
            resp_dict['released_ok']
        )

 def needs_agent_reference(self):
     return resolve_boolean(
         self._needs_agent_reference
     )

 def supports_billing_address(self):
     """Boolean indicating if billing address can be provided during
     purchase."""
     return resolve_boolean(
         self._supports_billing_address
     )

 def needs_email_address(self):
     """Boolean indicating if an email address is required for purchase."""
     return resolve_boolean(
         self._needs_email_address
     )

 def supports_https(self):
     """Boolean flag indicating HTTPS support."""
     return resolve_boolean(
         self._core_video_iframe.video_iframe_supports_https
     )

 def failed_3d_secure(self):
     """Boolean to indicate if the purchase attempt was marked with a
     3D secure failure."""
     return resolve_boolean(self._failed_3d_secure)

 def is_offer(self):
     """Boolean to indicate if the default concession for this ticket
     type is a special offer.
     """
     return resolve_boolean(self._core_price_band.is_offer)

 def is_main(self):
     """Flag to indicate if this is the primary category for the event."""
     if self._core_class:
         return resolve_boolean(self._core_class.is_main_class)
     else:
         return resolve_boolean(self._core_subclass.is_main_subclass)

 def need_duration(self):
     return resolve_boolean(
         self._get_core_event_attr('need_duration')
     )

 def need_performance(self):
     return resolve_boolean(
         self._get_core_event_attr('need_performance')
     )

 def show_perf_time(self):
     return resolve_boolean(
         self._get_core_event_attr('show_perf_time')
     )

 def is_seated(self):
     return resolve_boolean(
         self._get_core_event_attr('is_seated')
     )