https://github.com/crucialfelix/django-ajax-selects

To avoid having a large (and not sortable) dropdown for foreign key relationships in django admin

Right now we use SCSS for Orchestra dashboard/task styling and compile it with (django-libsass)[https://github.com/torchbox/django-libsass], but this functionality isn't currently available for custom step interfaces.

We now have an Orchestra API service in Angular (orchestra/static/orchestra/common/js/orchestra_api.js)

We should move all /orchestra/api/interface/ views to this service.

Without sending date header there is an error message about missing date header so I have added the date header in here.

from httpsig.requests_auth import HTTPSignatureAuth
from orch import settings
import requests

auth = HTTPSignatureAuth(key_id='orchestra-user',
                         secret='CHANGEME',
                         algorithm='hmac-sha256')
response = requests.get(
    'http://django.testsite.com:8000/orchestra/api/project/create_project',
    auth=auth,
    headers={"date": "10 29 2015"}
)

print(response.text)

This is returning

{"detail":"Authentication credentials were not provided."}

Also is there a way to change the authentication system for this so that I can use it without http signature?

There's an endpoint for this in the external-facing API, but there's no reason it shouldn't be surfaced in the Orchestra admin.

We use modals in Angular a lot---consider replacing boilerplate with a service.

Directive names need to be unique per step per version per workflow, which is tedious to do manually. In general, we should work on adding more angular scaffolding code!

Something equivalent to the javascript orchestraService.taskUtils.findPrerequisite() would be nice.

404, 403, 500, 400

Even a hard refresh sometimes does not refresh angular templates, especially if they are not loaded before the user refreshes the page. It is possible to use some grunt tasks to resolve this.

grunt-angular-templates concatenates all templates into a single js file. This is great as it prevents a delay as an ng-include tries to load a template on the fly and it also prevents selective caching of only some templates.

grunt-assets-versioning can prevent the caching of js (and other) files by automatically versioning the file names.

c.f. https://github.com/jasmine/jasmine/blob/master/RELEASE.md

So the orchestra project is self contained with all necessary endpoints

• http://orchestra.b12.io/
• http://orchestra.readthedocs.io/en/latest/concepts.html#life-of-a-task
• http://orchestra.readthedocs.io/en/latest/features.html

Right now we use a very vanilla implementation of django-registration-redux and the default django.contrib.auth.models.User model to handle registration.

We should customize this a bit so experts can add additional information like their slack handles to the database when they register.

Currently slack usernames can only be added using the admin.

We have core and utils modules, and then a bunch of stuff that’s not in those, like slack or google_apps. We should standardize all of these things :)

We're missing a few!

Right now Orchestra creates a new Slack group for each project. For certain workflows, it makes sense to have a single Slack group for all projects of that workflow type, so people working on similar projects can share best practices.

strawman: this command can update all of the workflow data (js, css, json) to point to the new version tag. Users may then add to the new workflow without a manual find & replace

https://api.slack.com/docs/message-buttons

When skipping a task, there can be zero task assignments resulting in a None returned here: https://github.com/b12io/orchestra/blob/master/orchestra/utils/task_lifecycle.py#L875

Providing a more helpful exception here would be great

Sending API requests to submit_task followed by save_task caused a malformed task state in which the task was marked as COMPLETE but the task assignment was overwritten as PROCESSING by the save function. In fact, all task assignment fields are overwritten to the values they had previous to the submit_task and save_task fields. Using select_from_update fixed the issue in this case, as selecting for update signals to Postgres to lock on the read rather than allow other read transactions to proceed. More broadly, however, we have not isolated other transactions, and might want to consider setting the db isolation level to SERIALIZABLE as per the Django docs.

Slack has deprecated usernames.

For Slack support in Orchestra, we already store user_ids, which aren't going away. We do, however, get that user_id by asking for a Slack username, which has been phased out. We should either ask for the user_id directly in account settings (it's accessible from the profile dropdown in Slack), or by searching for the user's display name.

In /simple_workflow/workflow.json, the sample_data_load_function object has module and name keys, but should be replaced by path, as in /journalism_workflow/workflow.json.

orchestra/views.py and orchestra/utils/machine_step_scheduler.py refer to settings.PRODUCTION and settings.STAGING These should be replaced by variables with semantically meaningful names, like settings.ORCHESTRA_IMAGE_UPLOAD_PREFIX.

Use a CDN, or even better, webpack require

Should be http://orchestra.b12.io/ I think?

Fresh install throwing an error about a missing template tag.

This should be made better over time. Current wishlist items include:

• Rip out the 'editor' form as a single angular directive to be more DRY
• Make the photo_adjustment step more realistic:
  • More realistic operations, e.g. rescaling/recoloring/thumbnails
  • More realistic workflow, e.g. creating multiple copies of each image and having the copy-editor
    caption the thumbnails
  • Write tests for the new google apps convenience/service methods (convenience.upload_file, convenience.download_file, service.list_folder, service.get_file_content)

Right now you have to be a developer to describe an Orchestra workflow. The Flash Teams work, and more specifically, Foundry show that it's possible for end-users to utilize a Gantt chart-like interface for describing workflows and step dependencies. For this to work in Orchestra, I'd imagine a few phases:

• Create a workflow description language that's not in Python, say in JSON or a DSL.
• Move workflows out of code and into the database with versions, so that we don't have to commit new code to update workflows
• Create a Gantt chart-like interface for describing workflows. If we can team up with the Foundry team to do this, all the better!

right now, versions are only tracked in setup.py, which is unfortunate.

• If we complete and skip a task, it should have a COMPLETED_AND_SKIPPED state
• If we complete a project, it should have a COMPLETED state

/staffbot staff 5 this is the best task ever

This will eliminate confusing interface pauses when doing things like submitting tasks, waiting for machine tasks, and sending emails.

Using something like angular-css and grunt-sass to selectively include stylesheets and decrease site overhead.

The Argonaut paper describes some simple ways to model a worker's aggregate work quality based on the results of several reviews. I'd imagine that as you focus on higher-level expertise, this problem becomes harder.

Issues with our current latency code:

• For tasks awaiting a new assignment, doesn't include an iteration 0 specifying how long they've been waiting
• For assignments in progress, doesn't include an row specifying how long they've been working on the current iteration
• The complete_tasks_only flag is out of place—latency code should analyze finalized data

Proposed solutions

• Create "empty" assignments for tasks awaiting a new assignment, to which an iteration 0 will belong
• Create an Iteration model to simplify logic
• Create a global project data module; latency code should remove incomplete tasks and assignments

We currently only support a review policy with a global sampling rate for all tasks of a particular type. Others will inevitably be useful:

• A per-user, per-task sampling rate. For example, Bob should be reviewed for photography tasks at a rate of 75%, whereas Alice should be reviewed at a rate of 25%.
• An Argonaut-style model-based review, where a model can determine which tasks will benefit from another level of review.

@jrbotros is working on this and will soon have a PR. Feel free to share your initial designs here, @jrbotros!

Add here: http://orchestra.readthedocs.io/en/latest/features.html

The controller PerformanceController is referenced in orchestra/static/orchestra/common/js/orchestra.routes.js but never defined

Function is at orchestra.utils.load_json and will catch json/decoding errors. This method should replace any manual calls to json.loads(x.decode()) so we catch any errors

Move project_details endpoint in urls.py into api/admin_api or something like it, for consistency with the other APIs.

simple_workflow and journalism_workflow should live in either a top level orchestra_examples/ folder or in orchestra/examples/

beanstalk_dispatch should either live inside orchestra/ or be a different repository entirely.