fsi.models.course_attendee
==========================

.. py:module:: fsi.models.course_attendee


Attributes
----------

.. autoapisummary::

   fsi.models.course_attendee.external_attendee_org


Classes
-------

.. autoapisummary::

   fsi.models.course_attendee.CourseAttendee


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

.. py:data:: external_attendee_org
   :value: 'Externe Kursteilnehmer'


.. py:class:: CourseAttendee

   Bases: :py:obj:`onegov.core.orm.Base`, :py:obj:`onegov.search.ORMSearchable`


   Comprises the user base mirrored by one-to-one relationship with
   onegov.user.User which is linked to the LDAP System including
   external users, that are created by an admin role.

   The onegov.user.User model should only contain email and role
   and is only used for authentication and permissions.

   All other attributes should be stored in here.

   Entries
   - external attendees: the do not have a link to a user
   - CourseAttendees linked to an admin role, aka Kursverantwortlicher
   - CourseAttendess linked to a member role, aka Kursbesucher



   .. py:attribute:: __tablename__
      :value: 'fsi_attendees'



   .. py:attribute:: es_properties

      Returns the type mapping of this model. Each property in the
      mapping will be read from the model instance.

      The returned object needs to be a dict or an object that provides
      a ``to_dict`` method.

      Internally, onegov.search stores differing languages in different
      indices. It does this automatically through langauge detection, or
      by manually specifying a language.

      Note that objects with multiple languages are not supported
      (each object is supposed to have exactly one language).

      Onegov.search will automatically insert the right analyzer for
      types like these.

      There's currently only limited support for properties here, namely
      objects and nested mappings do not work! This is going to be added
      in the future though.




   .. py:attribute:: es_public
      :value: False


      Returns True if the model is available to be found by the public.
      If false, only editors/admins will see this object in the search
      results.




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


   .. py:attribute:: user_id
      :type:  sqlalchemy.Column[uuid.UUID | None]


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


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


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


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


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


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


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


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


   .. py:method:: __str__() -> str


   .. py:attribute:: meta
      :type:  sqlalchemy.Column[dict[str, Any] | None]


   .. py:attribute:: subscriptions
      :type:  sqlalchemy.orm.relationship[onegov.core.types.AppenderQuery[fsi.models.course_subscription.CourseSubscription]]


   .. py:property:: title
      :type: str



   .. py:property:: lead
      :type: str | None



   .. py:property:: is_external
      :type: bool



   .. py:property:: role
      :type: str



   .. py:property:: email
      :type: str


      Needs a switch for external users



   .. py:property:: course_events
      :type: sqlalchemy.orm.Query[onegov.fsi.models.CourseEvent]


      Will return the query for not completed (future) courses events
       the attendee has a subscription record.



   .. py:property:: confirmed_course_events
      :type: sqlalchemy.orm.Query[onegov.fsi.models.CourseEvent]


      Registered future course events which have been confirmed 



   .. py:property:: total_done_course_events
      :type: sqlalchemy.orm.Query[onegov.fsi.models.CourseSubscription]



   .. py:property:: repeating_courses
      :type: sqlalchemy.orm.Query[onegov.fsi.models.CourseEvent]


      Will return query to filter for all upcoming courses the attendee
      has to refresh.

      This is necessary to answer: if one course, how many course events
      has an attendee: a) not registered if he had to or b) from the
      perspective of a course_event, was there a succeeding course event in
      the range of the refresh interval?




   .. py:property:: undone_registered_courses
      :type: sqlalchemy.orm.Query[onegov.fsi.models.CourseEvent]



   .. py:method:: possible_course_events(show_hidden: bool = True, show_locked: bool = False) -> sqlalchemy.orm.Query[onegov.fsi.models.CourseEvent]

      Used for the subscription form. Should exclude past courses
      and courses already registered