activity.collections.activity

Module Contents

Classes

ActivityFilter
ActivityCollection	Provides a pagination that supports loading multiple pages at once.

Attributes

AvailabilityType
ActivityT
AVAILABILITY_VALUES

activity.collections.activity.AvailabilityType: typing_extensions.TypeAlias

activity.collections.activity.ActivityT

activity.collections.activity.AVAILABILITY_VALUES: set[AvailabilityType]

class activity.collections.activity.ActivityFilter(**keywords: Unpack[FilterArgs])

property keywords: dict[str, str | list[str]]

__slots__ = ('age_ranges', 'available', 'price_ranges', 'dateranges', 'durations', 'municipalities',...

singular

age_ranges: set[tuple[int, int]]

available: set[AvailabilityType]

price_ranges: set[tuple[int, int]]

dateranges: set[tuple[datetime.date, datetime.date]]

durations: set[int]

municipalities: set[str]

owners: set[str]

period_ids: set[uuid.UUID]

states: set[onegov.activity.models.activity.ActivityState]

tags: set[str]

timelines: set[str]

weekdays: set[int]

volunteers: set[bool]

toggled(**keywords: Unpack[ToggledArgs]) → typing_extensions.Self

adapt_available(values: set[str]) → set[str]

adapt_num_ranges(values: set[str]) → set[tuple[int, int]]

adapt_age_ranges(values: set[str]) → set[tuple[int, int]]

adapt_price_ranges(values: set[str]) → set[tuple[int, int]]

adapt_dateranges(values: set[str]) → set[tuple[datetime.date, datetime.date]]

adapt_weekdays(values: set[str]) → set[int]

adapt_period_ids(values: set[str]) → set[uuid.UUID]

adapt_durations(values: set[str]) → set[int]

adapt_volunteers(values: set[str]) → set[bool]

encode(key: str, value: object) → str | list[str]

contains_num_range(value: tuple[int, int], ranges: Iterable[tuple[int, int]]) → bool

contains_age_range(age_range: tuple[int, int]) → bool

contains_price_range(price_range: tuple[int, int]) → bool

class activity.collections.activity.ActivityCollection(session: sqlalchemy.orm.Session, type: Literal[*, generic] = '*', pages: tuple[int, int] | None = None, filter: ActivityFilter | None = None)

class activity.collections.activity.ActivityCollection(session: sqlalchemy.orm.Session, type: str, pages: tuple[int, int] | None = None, filter: ActivityFilter | None = None)

Bases: onegov.core.collection.RangedPagination[ActivityT]

Provides a pagination that supports loading multiple pages at once.

This is useful in a context where a single button is used to ‘load more’ results one by one. In this case we need an URL that represents what’s happening on the screen (multiple pages are shown at the same time).

property page_range: tuple[int, int]

Returns the current page range (starting at (0, 0)).

property model_class: type[ActivityT]

property used_tags: set[str]

Returns a list of all the tags used on all activites of the current type.

property used_municipalities: set[str]

Returns a list of all the municipalities on all activites of the current type

subset() → Query[ActivityT]

Returns an SQLAlchemy query containing all records that should be considered for pagination.

by_page_range(page_range: tuple[int, int] | None) → typing_extensions.Self

Returns an instance of the collection limited to the given page range.

query_base() → Query[ActivityT]

Returns the query based used by query(). Overriding this function is useful to apply a general filter to the query before any other filter is applied.

For example, a policy can be enforced that only allows public activites.

query() → Query[ActivityT]

for_filter(**keywords: Unpack[ToggledArgs]) → typing_extensions.Self

Returns a new collection instance.

The given tag is excluded if already in the list, included if not yet in the list. Same goes for the given state.

Note that dateranges are excluded only if they match exactly. That is we don’t care about overlaps at all. If the same exact daterange is found in the filter, it is excluded.

by_id(id: uuid.UUID) → ActivityT | None

by_name(name: str) → ActivityT | None

by_user(user: onegov.user.User) → Query[ActivityT]

by_username(username: str) → Query[ActivityT]

get_unique_name(name: str) → str

Given a desired name, finds a variant of that name that’s not yet used. So if ‘foobar’ is already used, ‘foobar-1’ will be returned.

add(title: str, username: str, lead: str | None = None, text: str | None = None, tags: set[str] | None = None, name: str | None = None) → ActivityT

delete(activity: onegov.activity.models.Activity) → None

available_weeks(period: onegov.activity.models.Period | None) → Iterator[tuple[date, date]]

available_ages() → tuple[int, int] | None