• The motions select-field gets caught up in the checks for empty fields, and it shouldn't. Need to make the checks more refined than just every "select" element, it should really check for a class or something.
• It currently can't handle a variable number of speakers, or no replies, see #4 (Deal with this when dealing with that issue)
• Should it use a Javascript alert to alert errors as it currently does, or should we check form validation and return speaker position errors in form.non_field_errors as we currently do with some other checks (like draws and reply speaker conflicts)?

Catchall UI overhaul tasks, currently underway in the bootstrap branch

• Updating JQuery and related plugins to latest versions
• Implementing the Boostrap framework
• Various theme tweaks for usabability/consistency

I will admit, I am a bit of a novice with Python and code environments in general, but I will do my best to catch up. Love your work guys.

As far as I can tell, there is an actual issue with the install (as opposed to my own error). In the process of installing, psycopg2 (and possibly subsequently packages) need two additional steps:

First, it requires the package postgresql. On Mac, this involves running the command (as taken from here: https://stackoverflow.com/questions/5420789/how-to-install-psycopg2-with-pip-on-python):

brew install postgresql

Second, it requires bypassing an error regarding one of the "unknown arguments" in psycopg2's install (as well as at least one of the subsequent packages). Apparently XCode now treats unknown arguments as errors rather than warnings, so the following prefix is required to make the package install (as taken from here: http://bruteforce.gr/bypassing-clang-error-unknown-argument.html):

ARCHFLAGS=-Wno-error=unused-command-line-argument-hard-error-in-future

Which means the command now looks like:

ARCHFLAGS=-Wno-error=unused-command-line-argument-hard-error-in-future pip install -r requirements.txt

I don't know if there's anything that can be done at this end, but perhaps a note could be added to the install instructions for OS X 10.9 (or just XCode 5.1) users?

This only makes sense if the whole system is hosted on a publicly accessible server, with the associated security precautions. Not sure if this should be generated once and then static, or generated dynamically.

• Results by round
• Results by team
• Results by topic (if we implement topics)
• Mark split wins/losses as such
• Team tab
• Speaker tab
• Replies tab
• Scoresheets?

In my mind, this is most easily accomplished by writing a bash script that:

• Copies the raw HTML for the "published draw results" page
• Uploads it via FTP/scp up to a predefined server/location, ie www.australs2014.com/draw.html

Settings for the FTP server or SSH connection could live in local settings. I think its easier to have the draw go up to a separate server, given the tab software is often run over a local network rather than on an online server. This is essentially how it was previously done (except using the now-redundant Wordpress xmlrpc protocol). Thoughts?

Low priority.

This might help adjudication cores (and others) analyse results by topic (i.e. topic fairness). An interface would be needed to allow the administrator to enter the topics into the database after they are announced, since no-one knows the topics before then. Then when entering scoresheets, tab operators would select the motion as well.

The interface would appear on a single computer near the entrance of a tab room, and would only be available to those with administrator privileges (or a special class specifically for this purpose).

The boolean value should be tied to the ballot. This means that a new state in the ballot workflow would be created: the new state "Received" would appear between "None" and "Draft".

In 2012 we did this using an Excel spreadsheet.

This only makes sense if it is hosted on a publicly accessible server, with the appropriate security precautions.

• Draw for current and previous rounds
• Results (winners, splits and motions, not speaker scores) for current and previous rounds that are public knowledge
• Current team standings, and team standings after each of previous rounds
• All motions that have been released

We would want the current round draw only to be accessible publicly after is it put up in the briefing room, to avoid server overload issues.

On motions: In theory it should be a valid assumption that if the motion is in the database, then it is public knowledge, because motions should not be entered into the database until after the adjudicator core has released it (and there is a warning message on the edit motions form to this effect). But it would be sensible to limit public access to current and previous rounds, just in case.

To set up a tournament without needing to write a Python script (which is the status quo).

• teams
• venues
• speakers
• adjudicators
• conflicts
• institutions

Possible ways of doing this

• Standardize a CSV format and make everyone use the same one
• Allow any CSV format (or even Excel file) and have a user interface that gets the user to identify the fields. Actually, that's probably more hassle to program than it's worth.

Could point to appropriate commit at https://github.com/django/django but might be better to require installation of the official release from https://www.djangoproject.com/ ?

The (rough) idea:

• A public-facing page that lists pieces of feedback that the tab has yet to receive. Ie Team X on Adj Y, or Adj Y on Trainee Z.
• If we are being mean it could tally the total amounts of un-submitted feedback so that the list can be sorted to display the worst offenders
• The idea being to create a) a better norm of shame around un-submitted feedback. And b) notify the adj-core of important bits of feedback that may be missing.
• In terms of generating the data I guess it should look through all rounds except the last (or present) round to ensure there has been time for the feedback to be entered.

Thoughts?

At an upcoming tournament, there will be a number of teams that arrive and debate for 2 rounds on the sunday, but weren't around for the first 4 rounds on the Saturday. Am I right in thinking that if I add the Sunday-only teams in as Teams from the get-go, but leave them marked as Inactive until the 5th round that they will appear in the draw on 0 wins? Has the software been tested for this before?

Over the weekend I'll do the data entry required to fully test this, but though it would be good to ask and see if this has come up before / gauge any potential issues.

Currently uses integer increment/decrement (presumably the default?)

Should use:

• Minimum value equal to the minimum value set by ScoreField
• Maximum value equal to the maximum value set by ScoreField
• Step equal to 1 for substantive fields and 0.5 for reply fields

Either do this in HTML or maybe generate PDFs using ReportLab http://www.reportlab.com/software/opensource/

Would probably need to think this through. Tournaments should really be isolated from each other—different institutions, debaters, user accounts etc.—maybe to the extent of being different databases? But if hosted on a web server for multiple tournaments, the server would need to be able to service several at once.

Maybe a live feed on the dashboard?

• Store user and timestamp with data submission (if it isn't already there)
• Don't allow the monkey that entered the data to confirm the same data

At the point we have a public interface, do we want to add some sort of credits line to the footer? At the risk of going blind, it seems like a good chance to pimp our involvement and any related projects. Perhaps a link to our twitter/website, and perhaps related projects such as DebateKeeper.

Information we want to keep:

• Was this ballot submitted online, or entered by a tab monkey?
• When was this ballot submitted? (This is already in ActionLog.)
• How many times has this ballot been submitted?
• Who submitted this ballot?
  • We might need to store an e-mail address and/or phone number
• We need to be able to retain multiple submissions, in fact we may as well retain multiple submissions for tab monkeys as well

Thoughts for ballots:

• We don't want to create a database object called "Ballot" or anything like that - the data is already in the database as individual objects.
• But then we need a track record of ballot submissions with old scores, so as a minimum we will need an object that gets created for each ballot submission.
• Maybe add a "active" field to ballot scores?

Thoughts for feedback:

• Should just be able to add fields to the existing feedback model and just creating a new one for each submission?

I got this when running pip install -r requirements.txt:

Downloading/unpacking pylibmc (from django-pylibmc-sasl==0.2.4->-r requirements.txt (line 15))
  Running setup.py egg_info for package pylibmc

    warning: no files found matching 'LICENSE'
    warning: no files found matching 'runtests.py'
    warning: no files found matching '*.py' under directory 'pylibmc'
Installing collected packages: pylibmc
  Running setup.py install for pylibmc
    building '_pylibmc' extension
    gcc -pthread -fno-strict-aliasing -DNDEBUG -g -fwrapv -O2 -Wall -Wstrict-prototypes -fPIC -DUSE_ZLIB -I/usr/include/python2.7 -c src/_pylibmcmodule.c -o build/temp.linux-x86_64-2.7/src/_pylibmcmodule.o -fno-strict-aliasing
    In file included from src/_pylibmcmodule.c:34:0:
    src/_pylibmcmodule.h:42:36: fatal error: libmemcached/memcached.h: No such file or directory
    compilation terminated.
    error: command 'gcc' failed with exit status 1
    Complete output from command /home/czlee/git/tabbycat/venv/bin/python -c "import setuptools;__file__='/home/czlee/git/tabbycat/venv/build/pylibmc/setup.py';exec(compile(open(__file__).read().replace('\r\n', '\n'), __file__, 'exec'))" install --single-version-externally-managed --record /tmp/pip-wdEsqJ-record/install-record.txt --install-headers /home/czlee/git/tabbycat/venv/include/site/python2.7:
    running install

running build

running build_py

running build_ext

building '_pylibmc' extension

gcc -pthread -fno-strict-aliasing -DNDEBUG -g -fwrapv -O2 -Wall -Wstrict-prototypes -fPIC -DUSE_ZLIB -I/usr/include/python2.7 -c src/_pylibmcmodule.c -o build/temp.linux-x86_64-2.7/src/_pylibmcmodule.o -fno-strict-aliasing

In file included from src/_pylibmcmodule.c:34:0:

src/_pylibmcmodule.h:42:36: fatal error: libmemcached/memcached.h: No such file or directory

compilation terminated.

error: command 'gcc' failed with exit status 1

----------------------------------------
Command /home/czlee/git/tabbycat/venv/bin/python -c "import setuptools;__file__='/home/czlee/git/tabbycat/venv/build/pylibmc/setup.py';exec(compile(open(__file__).read().replace('\r\n', '\n'), __file__, 'exec'))" install --single-version-externally-managed --record /tmp/pip-wdEsqJ-record/install-record.txt --install-headers /home/czlee/git/tabbycat/venv/include/site/python2.7 failed with error code 1 in /home/czlee/git/tabbycat/venv/build/pylibmc
Storing complete log in /home/czlee/.pip/pip.log

Probably a dependency we need to instruct about, am looking it up.

Leave them separate in the database but do something useful so users don't have to compare them themselves. Even better, highlight differences or something.

Follows from #30.

Follows from #30.

At least, to my knowledge, you currently have to go to the tournament on the Django admin interface and modify the current round value.

Write an interface to allow debaters to submit feedback on adjudicators, instead of submitting a paper feedback form.

Benefits

• Would allow feedback to reach adjudication core before the next round scores, so it can help with judge allocation.

Risks

• Debaters and others might submit "bogus" forms, since it's easier to do so discreetly (maybe)

Points for discussion

1. Should this be a generally-available public interface with dropdown boxes? Or should we create user accounts for every debater, or every team, and require login in order to submit feedback, and restrict them to selecting debates they've been in that don't yet have feedback? Note this would require distinct login classes for debaters, judges and monkeys.
2. Adjudication cores have a habit of customising their own feedback forms, so we'd probably have to design this to be flexible if we can. Or for now, we can just ask the Australs 2014 adj core what they want to see, and design to that.

Potential following steps

• Write Android and iOS clients for the web form (with login if required)
• Extend to scoresheets

The reason judge feedback is higher priority than scoresheets is because judge feedback would actually come in a round earlier (we hope), whereas scoresheet data entry in the status quo doesn't tend to be the bottleneck.

...with error:

POST http://0.0.0.0:5000/t/dummy/round/1/adj_allocation/create/ 400 (BAD REQUEST)

Not sure what its posting (just the round number?), and if its the POST's fault or something in the parsing of the response. Initially I thought this was just due to the html changes, but seems like something else is going on.

It's not essential to fix for ADAM, but obviously definitely needs to be done at some point.

Including:

• Styles with two speakers only
• Styles with and without replies

Ideally, software code would be written to be even more generic in the back-end code, but for simplicity constrained at the front-end.

When we introduced BallotSubmissions, these broke because they total over all ballots, not just those that are confirmed.

Caused by #30.

Suggestion: use https://github.com/henriquebastos/django-aggregate-if.

Related to #30.

The new BallotSubmission statuses mess the tab monkey workflow up. Need to figure out how this should work when there are multiple ballots.

For inside the tab room, to go on projector (not visible to debaters).

Would have on it:

• Live feed, e.g. when results are entered or feedback is submitted
• Current round and status (e.g. "round in progress", "entering results")
• Progress statistics (e.g. "results 85% complete")

Probably a minor issue. But just putting it out there.

Might not be necessary, or might be necessitated by Django update (#1).
Repository is now at https://github.com/django-debug-toolbar/django-debug-toolbar

This might have been introduced by 614d793. I don't remember seeing it before then, at least. Or, I do remember seeing a similar issue to do with broken sorting, but I'm not sure if it was the same one as this. Note that that commit involves two database migrations, 0024 and 0025, so be careful when swapping between that commit and the one before it.

This also happens with team standings and speaker standings when you try to sort by team.

It's related to the jQuery dataTable plugin, not Django itself. I've tried sorting it properly in Python and it doesn't help because jQuery resorts it anyway. The dataTable plugin seems to be misinterpreting the table cell values or something.

Strangely, sorting by the team column in person availability works fine, perhaps because of the additional judge rows in the table?

Backup function would be user-driven via web interface, possibly they could download a file or something.

This isn't urgent (Australian Easters is a few days away now) but adding support for the style should be as simple as hiding (or automatically assigning a 0 value to) the reply speech score.

STATUS_BALLOT_IN complicates workflow checks. Since it doesn't affect the workflow, it shouldn't exist. It should be replaced with a Boolean field.

An unfortunate consequence is that the view logic becomes much more complicated: we now need to check both the debate status and the ballot-in field to see which icon to use and whether to display in red or orange.

On the other hand, we could just make a separate column to show whether the ballot has been checked in.

Related to #30 and #40.

• Priority order, don't forget to allow who-beat-whom multiple times
• Draw strength (also known as win points, opp wins)
• Bubbling type (random pull-up, pull-up from top, pull-up from bottom, intermediate bubble)
• Matching type (fold or slide)
• Who beat whom (for between two teams)

I'm currently referencing ballots by their ballot IDs. Since these are universally unique and number in the hundreds, this isn't ideal. Better to create a new field that auto-increments within each debate.

Related to #30.

In R1 of a new tournament, adding a new result as an admin crashes. The trace:

Request Method: GET
Request URL: http://0.0.0.0:5000/t/dummy/debate/1/new_ballots/

Django Version: 1.6.5
Python Version: 2.7.5
Installed Applications:
('suit',
 'django.contrib.admin',
 'django.contrib.auth',
 'django.contrib.contenttypes',
 'django.contrib.sessions',
 'django.contrib.sites',
 'django.contrib.staticfiles',
 'debate',
 'south',
 'emoji',
 'debug_toolbar',
 'gunicorn')
Installed Middleware:
('django.middleware.common.CommonMiddleware',
 'django.contrib.sessions.middleware.SessionMiddleware',
 'django.contrib.auth.middleware.AuthenticationMiddleware',
 'debate.middleware.DebateMiddleware',
 'django.contrib.messages.middleware.MessageMiddleware')


Traceback:
File "/Users/philip/Code/tabbycat/env/lib/python2.7/site-packages/django/core/handlers/base.py" in get_response
  112.                     response = wrapped_callback(request, *callback_args, **callback_kwargs)
File "/Users/philip/Code/tabbycat/env/lib/python2.7/site-packages/django/contrib/auth/decorators.py" in _wrapped_view
  22.                 return view_func(request, *args, **kwargs)
File "/Users/philip/Code/tabbycat/debate/views.py" in foo
  33.         return view_fn(request, request.tournament, *args, **kwargs)
File "/Users/philip/Code/tabbycat/debate/views.py" in new_ballots
  588.         form = forms.BallotSetForm(ballots)
File "/Users/philip/Code/tabbycat/debate/forms.py" in __init__
  96.         self.initial = self._initial_data()
File "/Users/philip/Code/tabbycat/debate/forms.py" in _initial_data
  167.         initial = {'debate_result_status': self.debate.result_status}

Exception Type: AttributeError at /t/dummy/debate/1/new_ballots/
Exception Value: 'BallotSetForm' object has no attribute 'debate'

Australs rules include a "one-up-one-down" rule, where if teams face each other a second time or if two teams from the same campus face each other during the preliminary rounds, limited attempts are made to swap teams between debates so that that doesn't happen. These aren't applicable to New Zealand tournaments, so we should allow options to disable this.

• Option to disable history conflict avoidance
• Option to disable campus conflict avoidance