Source code for parliament.models.commission

from __future__ import annotations

from datetime import date
from onegov.core.orm import Base
from onegov.core.orm.mixins import dict_markup_property
from onegov.core.orm.mixins import ContentMixin
from onegov.core.orm.mixins import TimestampMixin
from onegov.parliament import _
from onegov.core.orm import observes
from uuid import uuid4
from uuid import UUID
from sqlalchemy import Enum
from sqlalchemy.orm import mapped_column
from sqlalchemy.orm import relationship
from sqlalchemy.orm import Mapped


from typing import Literal
from typing import TYPE_CHECKING
if TYPE_CHECKING:
    from typing import TypeAlias

    from onegov.parliament.models import CommissionMembership



[docs]
CommissionType: TypeAlias = Literal[
    'normal',
    'intercantonal',
    'official',
]



[docs]
TYPES: dict[CommissionType, str] = {
    'normal': _('normal'),
    'intercantonal': _('intercantonal'),
    'official': _('official mission'),
}




[docs]
class Commission(Base, ContentMixin, TimestampMixin):


[docs]
    __tablename__ = 'par_commissions'



[docs]
    poly_type: Mapped[str] = mapped_column(default=lambda: 'generic')



[docs]
    __mapper_args__ = {
        'polymorphic_on': poly_type,
        'polymorphic_identity': 'generic',
    }


    @property

[docs]
    def title(self) -> str:
        return self.name


    #: Internal ID

[docs]
    id: Mapped[UUID] = mapped_column(
        primary_key=True,
        default=uuid4
    )


    #: External ID

[docs]
    external_kub_id: Mapped[UUID | None] = mapped_column(
        default=uuid4,
        unique=True
    )


    #: the name

[docs]
    name: Mapped[str]


    #: The start date

[docs]
    start: Mapped[date | None]


    #: The end date

[docs]
    end: Mapped[date | None]


    #: The type value

[docs]
    type: Mapped[CommissionType] = mapped_column(
        Enum(
            *TYPES.keys(),
            name='commission_type'
        ),
        default='normal'
    )


    #: The type as translated text
    @property

[docs]
    def type_label(self) -> str:
        return TYPES.get(self.type, '')


    #: The description

[docs]
    description = dict_markup_property('content')


    #: A commission may have n parliamentarians

[docs]
    memberships: Mapped[list[CommissionMembership]] = relationship(
        cascade='all, delete-orphan',
        back_populates='commission'
    )


    @observes('end')

[docs]
    def end_observer(self, end: date | None) -> None:
        if end:
            for membership in self.memberships:
                if not membership.end:
                    membership.end = end



[docs]
    def __repr__(self) -> str:
        return f'<Commission {self.name}>'