lichess4545/heltour

Chess tournament management software for the Lichess4545 league

heltour's Issues

Add a season action to update board order based on rating

This will be used just before pairings are created for a new round.

API: Get roster should include information about alternates

i.e. Which players are alternates for which boards.

API: Assign alternates

Make an API method for assigning a player to a team/board and a round. This should only work if the player is designated as an alternate for that board and is not already assigned for that round. Other cases can be handled manually by mods (?).

The API will be used (via Chesster) by captains to allow basic alternate management without mod intervention.

Lonewolf view: Pairings

For non-team seasons, the pairing page should be replaced with a modified version that displays pairings based on the LonePlayerPairing model.

Highlight scheduled alternates

Alternates that have been scheduled for the current round (or once complete, the upcoming round) should be highlighted. If captains/mods want to check future availability they can go to the player's profile page instead.

API: Find / Update Pairing

Make an API method for searching for a pairing based on one or two player names, with an optional league/season filter. It should return the complete set of information for each pairing.

Make an API method for updating the gamelink, or result of a pairing.

Currently chesster does the "Is moderator or is a member of the pairing" check so we could effectively allow this to work for any authenticated user.

API: Set unavailability

Make an API method for setting a player as unavailable for a given round. The API will be used (via Chesster) by players and captains. Players set as unavailable will be highlighted in the round's pairings.

TV Page

Make a TV page that shows all active games with game links. For now it can link to each game, but once lichess-org/lila#2096 is done, it can embed them with an iframe.

It should use a websocket or polling request to remove games after they are done (say 5 minutes after wards) and add new games as soon as they start.

The ordering should probably be by time started, so that new games are always added to the end of it, rather in the middle, but perhaps there are other ways of figuring this out.

Use JaVaFo for pairing generation

JaVaFo implements the FIDE dutch system for pairings.

Invite players to slack when their registration is approved

We can use the undocumented users.admin.invite API method. We may also want to add an action to invite players outside of the registration workflow.

Define what the home page should show

What should the home page show? Probably any active season standings (or links to them), plus a link to any "registration" if any are open, + link to rules / info about the league.

Update background task to use the multi-user endpoint

https://github.com/ornicar/lila#get-apiuser-fetch-many-users

We can search based on the lichess4545-league team and possibly the lone-wolf-3030 team as well. Not every player is guaranteed to be on those teams, so we'll need to keep track of which players weren't updated and request their ratings individually.

Lonewolf: Hide Rosters and Stats

For non-team leagues, the Rosters and Stats views should be hidden from the navbar. Also, the views should return 404.

Interview lonewolf and 45+45 mods

We should go through the weekly activities that these mods do, and make a list of "use cases" that we need to support for them and ensure the django admin supports them.

Create an Edit Rosters page

Mods should be able to use this page to build teams at the start of the season, as well as manage teams during a season.

It should allow players to be moved between teams/alternates, captains to be assigned and teams to be renamed. If the season hasn't started it should also allow teams to be created and deleted. Relevant information should be displayed about each player in a popover.

Create a round transition workflow

This will group common tasks for starting a new round.

• Setting the old round as completed and calculating scores
• Updating player ratings from the Lichess API
• Updating board order based on rating
• Creating and publishing pairings for the new round

Define and implement seed order

At the start of a season, teams should be seeded in a particular order (e.g. by average rating). This will be used for pairings and should not change for the duration of the season.

Handle byes and forfeits in JaVaFo interface

This isn't necessary for the team tournament (since teams can't get byes etc., only individuals), but will be needed for lone wolf pairing.

Make a registration page

Find the old registration form for season 4, and make a form that duplicates that information for a given league and make a version of this that works.

Create tests for existing code

https://docs.djangoproject.com/en/1.9/topics/testing/

Automated unit/integration tests will allow us to make changes (e.g. to support lone wolf) without worrying about unknowingly breaking things.

Lonewolf view: Standings

For non-team seasons, the standings page should be replaced with a modified version that displays standings based on individual scores.

Prereq: #42

Implement alternate management

• Players need a way to be assigned as alternates (see #21).
• Alternates need to be automatically sorted into buckets for different boards (see #25), and ordered based on their registration/last round played dates.
• Captains/mods need a way to see what alternates are available (see #12, #17, #33).
• Players/alternates need a way to be flagged as unresponsive (see #30).
• Alternates need a way to be assigned to a team/board/round (see #23).
• Pairings need to automatically update based on assigned alternates.

Lonewolf: Registration

The registration form should be modified for non-team seasons. Probably the easiest way to do this would be to separate the Registration model into team/lone versions.

Prioritize lichess API requests

Requests coming from chesster (e.g. to validate game links) need a higher priority over background rating updates.

API: Get roster for a league

There should be an API method to allow chesster to refresh the current roster for a given league.

This should include information about all players that are registered all teams that are formed and their members/captains.

It should also include information about alternates.

Highlight players with missed games

Players with missed games for the season should be highlighted on the rosters page. Yellow = 1 game missed, red = 2+ games missed.

Lonewolf view: Season landing

For non-team leagues, the season landing page (for both in progress and completed seasons) should be replaced with a modified version that displays standings and results in a way appropriate for lonewolf.

Prereq: #42

Lonewolf view: Dashboard

For non-team leagues, the admin dashboard should be replaced with a modified version with functionality appropriate for lonewolf seasons.

Make a season landing page

There should be a landing page for each season in the league. The season page should show or link to the standings, the results and the current pairings (if they exist).

We can probably design it after the lichess tournament pages in that after a season is done, first second and third place get a "trophy" at the top.

Create an alternative season view for completed seasons

The alternative landing page should display the final standings more prominently, e.g. with trophies for the top 3.

Implement the Stats page

There's a lot we can do with stats, but for now we should just duplicate the stats in the spreadsheet.

Make results pages

There should be a series (or maybe just a single?) of pages that show previous results for a given season.

API for welcome message

Chesster currently sends a welcome message to everyone that joins slack. Right now we have to redeploy chesster each time we want to change that message.

I am thinking that the current seasons can have a "Welcome" message on them, and chesster can ask the API for the current "welcome messages" and pass that along to the new signups. this way the mods can control that message from the heltour admin. Thoughts?

Create a background task to batch update ratings

Updating a large number of player ratings may take some time due to the lichess API limits. Therefore it should be performed as a background task with some mechanism (websockets?) to show progress.

Lonewolf: Scoring

A PlayerScore model should be added (similar to TeamScore) that's updated based on LonePlayerPairings. The Season.calculate_scores method should be split based on the type of league.

Add an unresponsive flag for players

The flag should be added to the SeasonPlayer model. Players marked as unresponsive should be highlighted on the rosters page.

Lonewolf view: League landing

For non-team leagues, the league landing page should be replaced with a modified version that displays the standings properly.

Prereq: #42

Cache for related object queries with select/prefetch_related isn't invalidated

Apparently this is a known issue/design choice for django-cacheops. There are ways to fix it within cacheops - for example, remove the select_related calls or add a .nocache() call. We could also look for other solutions.

Replace memoization with model caching

Some options to evaluate:

https://github.com/Suor/django-cacheops
https://github.com/django-cache-machine/django-cache-machine
https://github.com/jmoiron/johnny-cache

Add Notes fields to more models

Mods should be able to leave unstructured comments for future reference. On anything that makes sense - players, teams, pairings, etc.

Design / look of the site

I don't know if we have any designers amongst our midst. I should not be let anywhere near design, but we should come up with basic look and feel for the site.

I am leaning towards making it mobile optimized first with the full desktop view coming second. With that in mind, unless someone is willing to take on the job of doing all of the design, we should probably use something pre-built.

If it was up to me, I would pick some colours from Adobe Kuler, jam them into a custom Foundation CSS build and then build the site on the foundation grid with an eye towards making it super mobile friendly first. Using foundation means using jquery to get access to their plugins, but I'm fine with that.

Make a player-profile page

We can link to it wherever we show a username. Then we can have a link to create a new message in slack or on lichess and also have info about their participation, like years participated, etc.

Cross table can link to a "match result" page

The match result page can have a list of the matchups for that round between those two teams and show you the results.

Invalid HTTP_HOST header error on production

Full error message:
Invalid HTTP_HOST header: '173.230.151.075'. You may need to add u'173.230.151.075' to ALLOWED_HOSTS.

Seems to occur a few times a day for no particular reason.

Lonewolf: Round changes

An interface should be provided to allow mods to indicate when players register, withdraw, or have a bye.

Lonewolf view: Wallchart

For non-team seasons, instead of a crosstable view, a wallchart view should be added.

Also consider renaming the Crosstable page to "Results" and using the same endpoint for both views.

Prereq: #42

Create a league dashboard for admins

This should contextually show links to relevant actions so that mods don't have to manually dig into the Django admin interface to get common tasks done. In the future this can be expanded to show status indicators and other information.

Send a confirmation email when a registration is approved

The contents of the email would need to be defined.

Allow standings to be recalculated

Old results can be invalidated or modified in case of errors, cheaters, etc. The team scores will need to be recalculated in this case.

This could be a manually triggered task or automatic as the model detects and propagates changes.

Make a python script to populate our db from the current spreadsheet

It would be super beneficial for testing to have a script we can run on that populates the database from the current spreadsheet.

Also, unless we manage to time this perfectly, it's likely we'll launch in the middle of a season and will have to do this migration anyways.