activity.models.booking
=======================

.. py:module:: activity.models.booking


Attributes
----------

.. autoapisummary::

   activity.models.booking.BookingState


Classes
-------

.. autoapisummary::

   activity.models.booking.Booking


Module Contents
---------------

.. py:type:: BookingState
   :canonical: Literal['open', 'blocked', 'accepted', 'denied', 'cancelled']


.. py:class:: Booking

   Bases: :py:obj:`onegov.core.orm.Base`, :py:obj:`onegov.core.orm.mixins.TimestampMixin`


   Bookings are created by users for occasions.

   Initially, bookings are open. In this state they represent a "wish" rather
   than booking.

   Because bookings are wishes initially, they get a priority as well as
   a group code which links multiple bookings by multiple users together.

   They system will try to figure out the best booking using the priority
   as well as the group code.



   .. py:attribute:: __tablename__
      :value: 'bookings'



   .. py:method:: __hash__() -> int


   .. py:method:: __eq__(other: object) -> bool


   .. py:attribute:: id
      :type:  sqlalchemy.Column[uuid.UUID]


   .. py:attribute:: username
      :type:  sqlalchemy.Column[str]


   .. py:attribute:: priority
      :type:  sqlalchemy.Column[int]


   .. py:attribute:: group_code
      :type:  sqlalchemy.Column[str | None]


   .. py:attribute:: attendee_id
      :type:  sqlalchemy.Column[uuid.UUID]


   .. py:attribute:: occasion_id
      :type:  sqlalchemy.Column[uuid.UUID]


   .. py:attribute:: cost
      :type:  sqlalchemy.Column[decimal.Decimal | None]


   .. py:attribute:: score
      :type:  sqlalchemy.Column[decimal.Decimal]


   .. py:attribute:: period_id
      :type:  sqlalchemy.Column[uuid.UUID]


   .. py:attribute:: state
      :type:  sqlalchemy.Column[BookingState]


   .. py:attribute:: __table_args__


   .. py:attribute:: user
      :type:  sqlalchemy.orm.relationship[onegov.user.User]


   .. py:attribute:: attendee
      :type:  sqlalchemy.orm.relationship[onegov.activity.models.Attendee]


   .. py:attribute:: occasion
      :type:  sqlalchemy.orm.relationship[onegov.activity.models.occasion.Occasion]


   .. py:attribute:: period
      :type:  sqlalchemy.orm.relationship[onegov.activity.models.Period]


   .. py:method:: group_code_count(states: BookingStates | Literal['*'] = ('open', 'accepted')) -> int

      Returns the number of bookings with the same group code. 



   .. py:method:: period_bound_booking_state(period: onegov.activity.models.Period) -> BookingState

      During pre-booking we don't show the actual state of the booking,
      unless the occasion was cancelled, otherwise the user might see
      accepted bookings at a point where those states are not confirmed yet.

      This methods interprets the period/state accordingly.




   .. py:method:: set_priority_bit(index: int, bit: Literal[0, 1]) -> None

      Changes the priority, setting the the nth bit from the right to
      the value of ``bit`` (index/n begins at 0).

      The first bit (index=0) is reserved for starring/unstarring.
      The second bit (index=1) is reserved for nobble/unnobble.

      As a result, starring is less influental than locking.

      To give some context: Starring is used by the attendees to select
      which bookings they favor. Nobbling is used by administrators to force
      certain bookings to be preferred.




   .. py:method:: star(max_stars: int = 3) -> bool

      Stars the current booking, up to a limit per period and attendee.

      Starring sets the star-bit to 1.

      :return: True if successful (or already set), False if over limit.




   .. py:method:: unstar() -> None


   .. py:method:: nobble() -> None


   .. py:method:: unnobble() -> None


   .. py:attribute:: starred
      :type:  sqlalchemy.Column[bool]


   .. py:method:: nobbled() -> bool


   .. py:property:: dates
      :type: list[onegov.activity.models.OccasionDate]



   .. py:property:: order
      :type: int | None



   .. py:method:: overlaps(other: Booking, with_anti_affinity_check: bool = False) -> bool