def recipients_pool(self):
users = UserCollection(self.request.session)
users = users.query()
if self.state.data == ['active']:
users = users.filter(User.active == True)
elif self.state.data == ['inactive']:
users = users.filter(User.active == False)
elif self.state.data != ['active', 'inactive']:
return set()
return {u.username for u in users.with_entities(User.username)}
def username_choices(self):
assert self.request.is_admin # safety net
users = UserCollection(self.request.session)
users = users.by_roles('admin', 'editor')
users = users.with_entities(User.username, User.title)
def choice(row):
return row[0], row[1]
def by_title(choice):
return normalize_for_url(choice[1])
return sorted([choice(r) for r in users.all()], key=by_title)
def view_occasion_bookings_table(self, request):
layout = DefaultLayout(self, request)
wishlist_phase = self.period.wishlist_phase
booking_phase = self.period.booking_phase
phase_title = wishlist_phase and _("Wishlist") or _("Bookings")
users = UserCollection(request.session).query()
users = users.with_entities(User.username, User.id)
users = {u.username: u.id.hex for u in users}
def occasion_links(oid):
if self.period.finalized:
yield Link(
text=_("Signup Attendee"),
url='#',
traits=(
Block(_(
"The period has already been finalized. No new "
"attendees may be added."
), no=_("Cancel")),
)
)
else:
yield Link(
text=_("Signup Attendee"),
url=request.return_to(
request.class_link(Occasion, {'id': oid}, 'book'),
request.class_link(MatchCollection)
)
)
@lru_cache(maxsize=10)
def bookings_link(username):
return request.class_link(
BookingCollection, {
'period_id': self.period.id,
'username': username
}
)
@lru_cache(maxsize=10)
def user_link(username):
return request.return_here(
request.class_link(
User, {'id': users[username]}
)
)
@lru_cache(maxsize=10)
def attendee_link(attendee_id):
return request.return_here(
request.class_link(
Attendee, {'id': attendee_id}
)
)
@lru_cache(maxsize=10)
def group_link(group_code):
return request.class_link(
GroupInvite, {
'group_code': group_code
}
)
def booking_links(booking):
yield Link(_("User"), user_link(booking.attendee.username))
yield Link(_("Attendee"), attendee_link(booking.attendee_id))
yield Link(phase_title, bookings_link(booking.attendee.username))
if booking.group_code:
yield Link(_("Group"), group_link(booking.group_code))
if wishlist_phase:
yield Link(
text=_("Remove Wish"),
url=layout.csrf_protected_url(
request.class_link(Booking, {'id': booking.id})
),
traits=(
Confirm(_(
"Do you really want to remove ${attendee}'s wish?",
mapping={
'attendee': booking.attendee.name
}
), yes=_("Remove Wish"), no=_("Cancel")),
Intercooler(
request_method='DELETE',
target='#{}'.format(booking.id)
)
)
)
elif booking_phase and booking.state != 'accepted':
yield Link(
text=_("Remove Booking"),
url=layout.csrf_protected_url(
request.class_link(Booking, {'id': booking.id})
),
traits=(
Confirm(_(
"Do you really want to delete ${attendee}'s booking?",
mapping={
'attendee': booking.attendee.name
}
), yes=_("Remove Booking"), no=_("Cancel")),
Intercooler(
request_method='DELETE',
target='#{}'.format(booking.id)
)
)
)
elif booking_phase and booking.state == 'accepted':
yield Link(
text=_("Cancel Booking"),
url=layout.csrf_protected_url(
request.class_link(
Booking, {'id': booking.id}, 'cancel'
)
),
traits=(
Confirm(
_(
"Do you really want to cancel ${attendee}'s "
"booking?",
mapping={
'attendee': booking.attendee.name
}
),
_("This cannot be undone."),
_("Cancel Booking"),
_("Cancel")
),
Intercooler(
request_method='POST',
)
)
)
bookings = {'accepted': [], 'other': []}
q = request.session.query(Booking).filter_by(occasion_id=self.id)
q = q.options(joinedload(Booking.attendee))
for booking in q:
state = booking.state == 'accepted' and 'accepted' or 'other'
bookings[state].append(booking)
bookings['accepted'].sort(key=lambda b: normalize_for_url(b.attendee.name))
bookings['other'].sort(key=lambda b: normalize_for_url(b.attendee.name))
return {
'layout': layout,
'bookings': bookings,
'oid': self.id,
'occasion_links': occasion_links,
'booking_links': booking_links,
'period': self.period
}
def users_for_select_element(request):
u = UserCollection(request.session).query()
u = u.with_entities(User.id, User.username, User.title, User.realname)
u = u.order_by(func.lower(User.title))
u = u.filter_by(active=True)
return tuple(u)
def book_occasion(self, request, form):
# for the "nth. occasion" title
number = request.session.execute("""
SELECT count(*) FROM occasions
WHERE activity_id = :activity_id AND "order" <= :order
""", {
'activity_id': self.activity_id,
'order': self.order
}).scalar()
if form.submitted(request):
attendees = AttendeeCollection(request.session)
user = form.user
if form.is_new_attendee:
attendee = attendees.add(
user=user,
name=form.name,
birth_date=form.birth_date.data,
gender=form.gender.data,
notes=form.notes.data
)
else:
attendee = attendees.by_id(form.attendee.data)
assert attendee.username == form.username
# should be caught by the form
assert not (self.full and self.period.confirmed)
assert self.activity.state == 'accepted'
bookings = BookingCollection(request.session)
# if there's a canceled/denied booking blocking the way, reactivate it
booking = None
if not form.is_new_attendee:
booking = bookings.query()\
.filter(Booking.occasion_id == self.id)\
.filter(Booking.username == user.username)\
.filter(Booking.attendee == attendee)\
.filter(Booking.state.in_((
'cancelled',
'denied',
'blocked',
)))\
.first()
if booking:
booking.state = 'open'
if booking is None:
booking = bookings.add(
user=user,
attendee=attendee,
occasion=self
)
# if the TOS have been accepted, record this now
if hasattr(form, 'accept_tos') and form.accept_tos:
if form.accept_tos.data:
request.current_user.data['tos_accepted'] = True
if self.period.confirmed:
bookings.accept_booking(booking)
request.success(
_("The booking for ${name} was succesfull", mapping={
'name': attendee.name
})
)
else:
request.success(
_("The occasion was added to ${name}'s wishlist", mapping={
'name': attendee.name
}))
return request.redirect(request.link(self.activity))
title = _("Enroll Attendee")
users = []
if request.is_admin:
u = UserCollection(request.session).query()
u = u.with_entities(User.username, User.title)
u = u.order_by(User.title)
users = u
return {
'layout': OccasionFormLayout(self.activity, request, title),
'title': title,
'form': form,
'occasion': self,
'users': users,
'button_text': _("Enroll"),
'number': number,
}
