def populate_event_bookings(self, event_id):
event = get_event(event_id)
self.event_name.data = event.full_name()
self.sub_title.data = 'to date' if datetime.date.today(
) <= event.booking_end else ''
cd = event.course.course_data_as_of(event.date.year)
self.slope.data = cd.slope
total = 0
for booking in event.bookings:
item_form = BookingItemForm()
item_form.date = fmt_date(booking.date)
item_form.member_name = booking.member.player.full_name()
if booking.playing:
item_form.hcap = booking.member.player.state_as_of(
event.date).playing_handicap(event)
number = 1 + len(booking.guests)
item_form.number = number
total += number
item_form.guests = ', '.join([
g.name +
' ({})'.format(cd.apply_slope_factor(g.handicap, cd.slope))
for g in booking.guests
])
item_form.comment = booking.comment or ''
self.booking_list.append_entry(item_form)
self.total.data = total
def populate_tour_results(self, event_id):
event = get_event(event_id)
self.event_name.data = event.full_name()
venues = event.tour_events
for venue in venues:
venue_form = TourEventVenueItemForm()
venue_form.name = venue.course.name
self.venues.append_entry(venue_form)
results = get_tour_results(event)
player_names = get_player_names_as_dict(
results.get_columns('player_id'))
for res in results.data:
item_form = TourResultItemForm()
guest = "" if (
res[results.column_index('status')] != 0) else " (guest)"
item_form.position = res[results.column_index('position')]
item_form.player = player_names[res[results.column_index(
'player_id')]] + guest
item_form.total = res[results.column_index('total')]
for score in res[results.column_index('scores')]:
score_form = TourEventScoreItemForm()
score_form.points = score if score > 0 else ''
item_form.venue_scores.append_entry(score_form)
self.scores.append_entry(item_form)
def results_event(event_id):
event_id = int(event_id)
event_type = get_event(event_id).type
if event_type in [EventType.wags_vl_event, EventType.non_vl_event]:
return MaintainEvents.results_vl_event(event_id)
else:
return redirect(request.referrer)
def populate_card(self, event_id, player_id, position, handicap, status):
event = get_event(event_id)
course_data = event.course.course_data_as_of(event.date.year)
card = get_event_card(event_id, player_id)
self.event_name.data = event.full_name()
self.player.data = get_player(player_id).full_name()
self.handicap.data = handicap
self.positionReturn.data = position
self.handicapReturn.data = handicap
self.statusReturn.data = status
self.editable.data = is_event_result_editable(event)
holes = range(1, 19)
for hole in holes:
i = hole - 1
shots = "-" if card[i] == 99 or card[i] is None else card[i]
item_form = EventCardItemForm()
item_form.hole = hole
item_form.par = course_data.par[i]
item_form.si = course_data.si[i]
item_form.shots = shots
item_form.points = 0
if hole <= 9:
self.scoresOut.append_entry(item_form)
else:
self.scoresIn.append_entry(item_form)
def populate_event_report(self, event_id, report_file):
event = get_event(event_id)
self.event_name.data = event.full_name()
all = get_event_scores(event_id)
all.sort(['last_name', 'first_name'])
if len(all.data) == 0:
return False
def lu_fn(values):
return values['status'] == PlayerStatus.member
members = all.where(lu_fn)
players = all.get_columns('player_name')
pos = [s for s in members.get_columns('position')]
pos = pos.index(min(pos))
self.winner.data = members.get_columns('player_name')[pos]
self.winner_return.data = self.winner.data
set_select_field(self.ntp, 'player', players)
set_select_field(self.ld, 'player', players)
report = get_file_contents(report_file)
if report:
values = get_elements_from_html(report, ['ld', 'ntp', 'report'])
if len(values) == 0:
values = self.alt_get_report_elements_from_html(
report, {
'ld': 'Longest Drive:',
'ntp': 'Nearest the Pin:'
})
self.ntp.data = values['ntp']
self.ld.data = values['ld']
self.report.data = values.get('report') or ''
return True
def populate_event_handicaps(self, event_id):
self.event_id.data = event_id
event = get_event(event_id)
self.event_name.data = event.full_name()
scratch = competition_scratch_score(event)
self.new_date.data = fmt_date(event.date + datetime.timedelta(days=1))
self.editable.data = True # is_latest_event(event)
if self.editable.data:
next_event_date = datetime.date.today()
else:
next_event = get_next_event(event.date)
if next_event:
next_event_date = next_event.date
else:
next_event_date = datetime.date.today()
num = 0
for player in sorted_players_for_event(event):
num += 1
item_form = EventHandicapItemForm()
item_form.num = str(num)
orig_state = player.state_as_of(event.date)
new_state = player.state_as_of(next_event_date)
item_form.player = player.full_name() + orig_state.status.qualify()
item_form.handicap = new_state.handicap
item_form.old_handicap = orig_state.handicap
score = player.score_for(event.id)
item_form.suggested = suggested_handicap_change(
scratch, orig_state.handicap, score.points)
item_form.points = score.points
item_form.strokes = score.shots
item_form.position = score.position
item_form.player_id = player.id
item_form.status_return = orig_state.status.value
item_form.old_handicap_return = orig_state.handicap
self.scores.append_entry(item_form)
def calc_event_positions(event_id, result):
event = get_event(event_id)
course_data = event.course.course_data_as_of(event.date.year)
if 'card' not in result.head:
cards = get_event_cards(event_id)
else:
cards = {
pc[0]: pc[1]
for pc in result.get_columns(['player_id', 'card']) if pc[1]
}
sort = []
for row in result.data:
player = dict(zip(result.head, row))
player_id = int(player['player_id'])
player_hcap = my_round(float(player['handicap']))
if player_id in cards:
shots = [int(s) for s in cards[player_id]]
points = calc_stableford_points(player_hcap, shots, course_data.si,
course_data.par)
# countback
tot = (1e6 * sum(points[-18:])) + (1e4 * sum(points[-9:])) + (
1e2 * sum(points[-6:])) + sum(points[-3:])
else:
tot = 1e6 * coerce(player['points'], float)
sort.append(tot)
result.sort_using(sort, reverse=True)
position = list(range(1, len(result.data) + 1))
result.update_column('position', position)
return result
def populate_event(self, event_id, event_type):
event = get_event(event_id)
if not event_type:
event_type = event.type
self.editable = is_event_editable(event.date.year)
self.date.data = event.date
self.member_price.data = event.member_price
self.guest_price.data = event.guest_price
self.start_booking.data = event.booking_start
self.end_booking.data = event.booking_end
self.max.data = event.max
self.event_type.data = event_type.value
self.note.data = event.note
if event_type in [
EventType.wags_vl_event, EventType.non_vl_event,
EventType.non_event, EventType.cancelled
]:
for item in event.schedule + (6 -
len(event.schedule)) * [Schedule()]:
item_form = ScheduleForm()
item_form.time = item.time
item_form.text = item.text
self.schedule.append_entry(item_form)
if event_type in [EventType.wags_tour, EventType.minotaur]:
for item in event.tour_events + (
6 - len(event.tour_events)) * [Event()]:
item_form = TourScheduleForm()
item_form.date = item.date
self.tour_schedule.append_entry(item_form)
self.populate_choices(event_id, event_type)
return event_id
def populate_event(self, event_id, member_id):
event = get_event(event_id)
self.bookable.data = event.is_bookable()
self.at_capacity.data = event.at_capacity()
if self.bookable.data:
self.title.data = 'Book Event'
else:
self.title.data = 'Event Details'
self.show_bookings.data = len(event.bookings) > 0
self.event_id.data = event_id
self.event_type.data = event.type
self.date.data = encode_date(event.date)
if event.organiser:
self.organiser_id.data = event.organiser.id
self.organiser.data = event.organiser.player.full_name()
else:
self.organiser_id.data = 0
self.event.data = event.trophy.name if event.trophy else event.venue.name
self.venue.data = event.venue.name
contact = event.venue.contact or Contact()
post_code = contact.post_code or ''
self.venue_address.data = line_break(
(contact.address or '') + ',' + post_code, [',', '\r', '\n'])
self.venue_phone.data = contact.phone or ''
self.map_url.data = 'http://maps.google.co.uk/maps?q={}&title={}&z=12 target="googlemap"' \
.format(post_code.replace(' ', '+'), event.venue.name)
self.venue_directions.data = line_break(event.venue.directions or '',
'\n')
self.schedule.data = line_break([(s.time.strftime('%H:%M ') + s.text)
for s in event.schedule])
self.member_price.data = event.member_price
self.guest_price.data = event.guest_price
self.booking_deadline.data = encode_date(event.booking_end)
self.notes.data = event.note or ''
if member_id == 0:
self.message.data = ''
return
booking = get_booking(event_id, member_id)
if not booking.id:
booking.member = get_member(member_id)
booking.playing = True
self.message.data = self.booking_message(event, booking)
if event.is_bookable() or booking.id:
self.attend.data = booking.playing
self.comment.data = booking.comment
self.booking_date.data = fmt_date(booking.date)
self.member_name.data = booking.member.player.full_name()
count = 1
for guest in booking.guests + (3 -
len(booking.guests)) * [Guest()]:
item_form = GuestForm()
item_form.item_pos = count
item_form.guest_name = guest.name
item_form.handicap = guest.handicap
self.guests.append_entry(item_form)
count += 1
def populate_history(self, player_id, event_id):
player = get_player(player_id)
event = get_event(event_id)
self.player.data = player.full_name()
for item in player.states_up_to(event.date):
item_form = HandicapItemForm()
item_form.date = fmt_date(item.date)
item_form.handicap = item.handicap
item_form.status = item.status.name
self.history.append_entry(item_form)
def populate_history(self, event_id, player_id):
event = get_event(event_id)
if is_latest_event(event):
date = datetime.date.today()
else:
date = event.date
player = get_player(player_id)
self.player.data = player.full_name()
for state in player.states_up_to(date):
item_form = HandicapItemForm()
item_form.date = state.date
item_form.handicap = state.handicap
item_form.status = state.status.name
self.history.append_entry(item_form)
def report_event(event_id):
event = get_event(event_id)
form = EventReportForm()
if form.is_submitted():
if form.save:
MaintainEvents.save_report_page('static/event_report.html', event, form)
flash('report saved', 'success')
return redirect(url_for_admin('list_events', year=event.date.year))
else:
report_file = MaintainEvents.report_file_name(event.date)
if not form.populate_event_report(event_id, report_file):
flash('Results not yet available', 'warning')
return redirect(url_for_admin('events_main', event_id=event_id))
return render_template('admin/event_report.html', form=form, event=event_id)
def populate_event_results(self, event_id):
event = get_event(event_id)
self.event_id.data = event_id
self.event_name.data = event.full_name()
for score in [s for s in event.scores if s.points > 0]:
item_form = EventResultItemForm()
player = score.player
state = player.state_as_of(event.date)
item_form.player = player.full_name() + state.status.qualify()
item_form.handicap = state.playing_handicap(event)
item_form.points = score.points
item_form.strokes = score.shots
item_form.position = score.position
item_form.player_id = player.id
self.scores.append_entry(item_form)
def save_event_handicaps(self, event_id):
errors = self.errors
if len(errors) > 0:
return False
date = get_event(event_id).date + datetime.timedelta(days=1)
fields = ['player_id', 'date', 'status', 'handicap']
data = [[
int(d['player_id']), date,
PlayerStatus(int(d['status_return'])),
float(d['handicap'])
] for d in self.data['scores']
if d['handicap'] != d['old_handicap_return']]
save_handicaps(Table(fields, data))
return True
def populate_choices(self, event_id, event_type):
courses = get_course_select_choices()
event = get_event(event_id)
organiser = event.organiser.id if event.organiser else 0
trophy = event.trophy.id if event.trophy else 0
venue = event.venue.id if event.venue else 0
course = event.course.id if event.course else 0
set_select_field_new(self.organiser,
get_member_select_choices(),
default_selection=organiser,
item_name='Organiser')
set_select_field_new(self.trophy,
get_trophy_select_choices(),
default_selection=trophy,
item_name='Trophy')
set_select_field_new(self.venue,
get_venue_select_choices(),
default_selection=venue,
item_name='Venue')
if event_type in [
EventType.wags_vl_event, EventType.non_vl_event,
EventType.non_event, EventType.cancelled
]:
set_select_field_new(self.course,
courses,
default_selection=course,
item_name='Course')
if event_type in [EventType.wags_tour, EventType.minotaur]:
item_count = 0
for item in event.tour_events + (
6 - len(event.tour_events)) * [Event()]:
course_id = item.course_id if item.course else 0
field = self.tour_schedule.entries[item_count].course
set_select_field_new(field,
courses,
default_selection=course_id,
item_name='Course')
item_count += 1
def populate_card(self, event_id, player_id):
event = get_event(event_id)
player = get_player(player_id)
card = get_event_card(event_id, player_id)
course_data = event.course.course_data_as_of(event.date.year)
state = player.state_as_of(event.date)
self.event_name.data = event.full_name()
self.player.data = player.full_name()
self.handicap.data = state.playing_handicap(event)
holes = range(1, 19)
for hole in holes:
i = hole - 1
shots = "-" if card[i] == 99 or card[i] is None else card[i]
item_form = EventCardItemForm()
item_form.hole = hole
item_form.par = course_data.par[i]
item_form.si = course_data.si[i]
item_form.shots = shots
item_form.points = 0
if hole <= 9:
self.scoresOut.append_entry(item_form)
else:
self.scoresIn.append_entry(item_form)
