def scenario_update(request, exptr_id=None, exp_id=None, scen_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
exp_id = pk_to_int_or_404(exp_id)
exp = get_object_or_404(models.Experiment, pk=exp_id)
scen_id = pk_to_int_or_404(scen_id)
scen = get_object_or_404(models.Scenario, pk=scen_id)
if "GET" == request.method:
form = forms.ScenarioForm(
initial={'current_file': scen.curr_scen_file},
instance=scen)
else:
form = forms.ScenarioForm(request.POST, request.FILES, instance=scen)
if form.is_valid():
# if 'scenario_file' in form.changed_data:
# delete_scenario_file(scen_id)
form.save()
# send them to the exp edit page
return redirect(exp.get_update_url())
ctx = mk_ee_context(
breadcrumbs=create_ee_breadcrumbs(exptr, exp, scen),
title="Scenario Editor",
experimenter=exptr,
experiment=exp,
scen=scen,
enctype="multipart/form-data",
form=form)
return render(request,
"django_tutalk/experiment_editor/scenario_update.html",
ctx)
def post_training_task_update(request,
exptr_id=None, exp_id=None, task_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
exp_id = pk_to_int_or_404(exp_id)
exp = get_object_or_404(models.Experiment, pk=exp_id)
task_id = pk_to_int_or_404(task_id)
task = get_object_or_404(models.PostTrainingTask, pk=task_id)
if "GET" == request.method:
form = forms.PostTrainingTaskForm(instance=task)
else:
form = forms.PostTrainingTaskForm(request.POST, instance=task)
if form.is_valid():
task = form.save()
# send them to the exp edit page
return redirect(exp.get_update_url())
ctx = mk_ee_context(
breadcrumbs=create_ee_breadcrumbs(exptr, exp, task),
title="Post-Training Task Editor",
experimenter=exptr,
experiment=exp,
task=task,
form=form)
return render(
request,
"django_tutalk/experiment_editor/simple_entity_update.html",
ctx)
def experiment_delete(request, exptr_id=None, exp_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
exp_id = pk_to_int_or_404(exp_id)
exp = get_object_or_404(models.Experiment, pk=exp_id)
exp.delete()
return redirect(exptr.get_update_url())
def custom_parameter_delete(request, app_id=None, cparam_id=None):
app_id = pk_to_int_or_404(app_id)
app = get_object_or_404(models.App, id=app_id)
cparam_id = pk_to_int_or_404(cparam_id)
cparam = get_object_or_404(models.CustomParameter, id=cparam_id)
cparam.delete()
return redirect(app.get_update_url())
def parameter_delete(request, app_id=None, param_id=None):
app_id = pk_to_int_or_404(app_id)
app = get_object_or_404(models.App, id=app_id)
param_id = pk_to_int_or_404(param_id)
param = get_object_or_404(models.Parameter, id=param_id)
param.delete()
return redirect(app.get_update_url())
def experiment_update(request, exptr_id=None, exp_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
exp_id = pk_to_int_or_404(exp_id)
exp = get_object_or_404(models.Experiment, pk=exp_id)
if "GET" == request.method:
form = forms.ExperimentForm(instance=exp)
et_choices = get_experiment_types()
form.fields["experiment_type"].choices = et_choices
else:
form = forms.ExperimentForm(request.POST, instance=exp)
if form.is_valid():
form.save()
return redirect(exp.get_update_url()) # stay on edit page
ctx = mk_ee_context(
breadcrumbs=create_ee_breadcrumbs(exptr, exp),
title="Experiment Editor",
experimenter=exptr,
experiment=exp,
conditions=exp.conds,
post_training_tasks=exp.post_training_tasks,
pre_training_tasks=exp.pre_training_tasks,
scenarios=exp.scens,
sites=exp.sites,
create_condition=exp.get_create_condition_url(),
create_post_training_task=exp.get_create_post_training_task_url(),
create_pre_training_task=exp.get_create_pre_training_task_url(),
create_scenario=exp.get_create_scenario_url(),
create_site=exp.get_create_site_url(),
form=form)
return render(request,
"django_tutalk/experiment_editor/experiment_update.html",
ctx)
def condition_update(request, exptr_id=None, exp_id=None, cond_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
exp_id = pk_to_int_or_404(exp_id)
exp = get_object_or_404(models.Experiment, pk=exp_id)
cond_id = pk_to_int_or_404(cond_id)
cond = get_object_or_404(models.Condition, pk=cond_id)
if "GET" == request.method:
form = forms.ConditionForm(instance=cond)
else:
form = forms.ConditionForm(request.POST, instance=cond)
if form.is_valid():
form.save()
# send them to the exp edit page
return redirect(exp.get_update_url())
ctx = mk_ee_context(
breadcrumbs=create_ee_breadcrumbs(exptr, exp, cond),
title="Condition Editor",
experimenter=exptr,
experiment=exp,
condition=cond,
training_tasks=cond.training_tasks,
create_training_task=cond.get_create_training_task_url(),
form=form)
return render(request,
"django_tutalk/experiment_editor/condition_update.html",
ctx)
def training_task_create(request, exptr_id=None, exp_id=None, cond_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
exp_id = pk_to_int_or_404(exp_id)
exp = get_object_or_404(models.Experiment, pk=exp_id)
cond_id = pk_to_int_or_404(cond_id)
cond = get_object_or_404(models.Condition, pk=cond_id)
if "GET" == request.method:
form = forms.TrainingTaskForm(initial={
"condition": cond,
"experiment": exp})
else:
form = forms.TrainingTaskForm(request.POST)
if form.is_valid():
form.save()
# send them back to exp edit page
return redirect(cond.get_update_url())
ctx = mk_ee_context(
breadcrumbs=create_ee_breadcrumbs(exptr, exp, cond,
{"label": "Training Task: new"}),
title="Create Training Task",
experimenter=exptr,
experiment=exp,
condition=cond,
form=form)
return render(request,
"django_tutalk/experiment_editor/entity_create.html",
ctx)
def participant_update(request,
exptr_id=None, exp_id=None, site_id=None, part_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
exp_id = pk_to_int_or_404(exp_id)
exp = get_object_or_404(models.Experiment, pk=exp_id)
site_id = pk_to_int_or_404(site_id)
site = get_object_or_404(models.Site, pk=site_id)
part_id = pk_to_int_or_404(part_id)
part = get_object_or_404(models.Participant, pk=part_id)
if "GET" == request.method:
form = forms.ParticipantForm(instance=part)
else:
save_form = False
form = forms.ParticipantForm(request.POST, instance=part)
if form.is_valid():
if "assigned_to_user" in form.changed_data:
if form.cleaned_data["assigned_to_user"]:
ve = ValidationError(
"You can only disassociate a user from a participant",
code="invalid"
)
form.add_error("assigned_to_user", ve)
else:
# get the tutalk user associated with the participant
tutalk_user = \
models.TuTalkUser.objects\
.filter(participants__id=part.id)\
.first()
if tutalk_user is None:
ve = ValidationError(
"Unable to find user assigned to this participant",
code="invalid"
)
form.add_error("assigned_to_user", ve)
else:
# de-assign the participant from tutalk_user
save_form = True
tutalk_user.participants.remove(part)
tutalk_user.save()
if tutalk_user.promo_code.site is not None:
# tutalk user is bound to a particular site
# the are a student user, delete the tutalk_user
# which means that their auth_user will remain
# but they will need to re-register with a promo
# code
tutalk_user.delete()
else:
# assigned_to_user is unchanged
save_form = True
if save_form:
form.save()
return redirect(site.get_update_url())
ctx = mk_ee_context(
breadcrumbs=create_ee_breadcrumbs(exptr, exp, site, part),
title="Participant Editor",
form=form)
return render(request,
"django_tutalk/experiment_editor/simple_entity_update.html",
ctx)
def site_update(request, exptr_id=None, exp_id=None, site_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
exp_id = pk_to_int_or_404(exp_id)
exp = get_object_or_404(models.Experiment, pk=exp_id)
site_id = pk_to_int_or_404(site_id)
site = get_object_or_404(models.Site, pk=site_id)
parts = site.parts
conds = exp.conds
bulk_form_attrs = get_bulk_form_attributes(site,
parts,
conditions=conds)
bulk_forms = initialize_bulk_forms(request, site, parts, bulk_form_attrs)
if "GET" == request.method:
form = forms.SiteForm(instance=site)
else:
form = forms.SiteForm(request.POST, instance=site)
if form.is_valid():
form.save()
# keep them on site edit page
return redirect(site.get_update_url())
ctx = mk_ee_context(
breadcrumbs=create_ee_breadcrumbs(exptr, exp, site),
title="Site Editor",
experimenter=exptr,
experiment=exp,
site=site,
participants=parts,
num_participant_columns=calculate_participant_list_num_cols(parts),
form=form)
ctx.update(bulk_forms)
return render(request,
"django_tutalk/experiment_editor/site_update.html",
ctx)
def condition_delete(request, exptr_id=None, exp_id=None, cond_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
exp_id = pk_to_int_or_404(exp_id)
exp = get_object_or_404(models.Experiment, pk=exp_id)
cond_id = pk_to_int_or_404(cond_id)
cond = get_object_or_404(models.Condition, pk=cond_id)
cond.delete()
return redirect(exp.get_update_url())
def post_training_task_delete(request,
exptr_id=None, exp_id=None, task_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
exp_id = pk_to_int_or_404(exp_id)
exp = get_object_or_404(models.Experiment, pk=exp_id)
task_id = pk_to_int_or_404(task_id)
task = get_object_or_404(models.PostTrainingTask, pk=task_id)
task.delete()
return redirect(exp.get_update_url())
def scenario_delete(request, exptr_id=None, exp_id=None, scen_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
exp_id = pk_to_int_or_404(exp_id)
exp = get_object_or_404(models.Experiment, pk=exp_id)
scen_id = pk_to_int_or_404(scen_id)
scen = get_object_or_404(models.Scenario, pk=scen_id)
# delete_scenario_file(scen_id)
scen.delete()
return redirect(exp.get_update_url())
def bulk_participant_update(request, exptr_id=None, exp_id=None, site_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
exp_id = pk_to_int_or_404(exp_id)
exp = get_object_or_404(models.Experiment, pk=exp_id)
site_id = pk_to_int_or_404(site_id)
site = get_object_or_404(models.Site, pk=site_id)
conds = exp.conds
parts = site.parts
cond_name_ids = {(cond.name, cond.id) for cond in conds}
bulk_form_attrs = get_bulk_form_attributes(site,
parts,
conditions=conds)
bulk_forms = initialize_bulk_forms(request, site, parts, bulk_form_attrs)
bulk_update_form = forms.BulkParticipantUpdateForm(request.POST)
if bulk_update_form.is_valid():
form_data = get_bulk_form_data(bulk_update_form,
parts,
conditions=conds)
req_update_uids = set(form_data["requested_uids"])
existing_uids = set(form_data["existing_uids"])
cond_cycler = form_data["condition_cycler"]
cond_names = form_data["cond_names"]
missing_uids = req_update_uids - existing_uids
if len(missing_uids) == 0:
for uid in sorted(req_update_uids):
part = get_participant_by_site_uid(site, uid)
part.condition = next(cond_cycler)
part.save()
return redirect(site.get_update_url())
else:
bulk_update_form.add_error(
"first_uid",
ValidationError("uid %d doesn't exist" %
min(missing_uids),
code="invalid"))
bulk_update_form.add_error(
"last_uid",
ValidationError("uid %d doesn't exist" %
max(missing_uids),
code="invalid"))
ctx = mk_ee_context(
breadcrumbs=create_ee_breadcrumbs(exptr, exp, site),
title="Site Editor",
experimenter=exptr,
experiment=exp,
site=site,
participants=parts,
num_participant_columns=calculate_participant_list_num_cols(parts),
form=forms.SiteForm(instance=site))
ctx.update(bulk_forms)
ctx["bulk_update_form"] = bulk_update_form
return render(request,
"django_tutalk/experiment_editor/site_update.html",
ctx)
def training_task_delete(request, exptr_id=None, exp_id=None, cond_id=None,
task_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
exp_id = pk_to_int_or_404(exp_id)
exp = get_object_or_404(models.Experiment, pk=exp_id)
cond_id = pk_to_int_or_404(cond_id)
cond = get_object_or_404(models.Condition, pk=cond_id)
task_id = pk_to_int_or_404(task_id)
task = get_object_or_404(models.TrainingTask, pk=task_id)
task.delete()
return redirect(cond.get_update_url())
def parameter_update(request, app_id=None, param_id=None):
app_id = pk_to_int_or_404(app_id)
app = get_object_or_404(models.App, id=app_id)
param_id = pk_to_int_or_404(param_id)
param = get_object_or_404(models.Parameter, id=param_id)
if "GET" == request.method:
form = forms.ParameterForm(instance=param)
else:
form = forms.ParameterForm(request.POST, instance=param)
if form.is_valid():
form.save()
return redirect(app.get_update_url())
ctx = mk_ee_context(
breadcrumbs=create_ee_breadcrumbs(app, param),
title="App Parameter Editor",
form=form)
return render(request,
'django_tutalk/experiment_editor/simple_entity_update.html',
ctx)
def site_create(request, exptr_id=None, exp_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
exp_id = pk_to_int_or_404(exp_id)
exp = get_object_or_404(models.Experiment, pk=exp_id)
if "GET" == request.method:
form = forms.SiteForm(initial={"experiment": exp})
else:
form = forms.SiteForm(request.POST)
if form.is_valid():
site = form.save()
# send them to the site edit page
return redirect(site.get_update_url())
ctx = mk_ee_context(
breadcrumbs=create_ee_breadcrumbs(exptr, exp, {"label": "Site: new"}),
title="Create Site",
experimenter=exptr,
experiment=exp,
form=form)
return render(request,
"django_tutalk/experiment_editor/entity_create.html",
ctx)
def scenario_create(request, exptr_id=None, exp_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
exp_id = pk_to_int_or_404(exp_id)
exp = get_object_or_404(models.Experiment, pk=exp_id)
if "GET" == request.method:
form = forms.ScenarioForm(initial={"experiment": exp})
else:
form = forms.ScenarioForm(request.POST, request.FILES)
LOGGER.debug(form.data)
if form.is_valid():
form.save()
return redirect(exp.get_update_url())
ctx = mk_ee_context(
breadcrumbs=create_ee_breadcrumbs(exptr, exp,
{"label": "Scenario: new"}),
title="Create Scenario",
experimenter=exptr,
experiment=exp,
enctype="multipart/form-data",
form=form)
return render(request,
"django_tutalk/experiment_editor/entity_create.html",
ctx)
def bulk_participant_delete(request, exptr_id=None, exp_id=None, site_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
exp_id = pk_to_int_or_404(exp_id)
exp = get_object_or_404(models.Experiment, pk=exp_id)
site_id = pk_to_int_or_404(site_id)
site = get_object_or_404(models.Site, pk=site_id)
parts = site.parts
bulk_form_attrs = get_bulk_form_attributes(site,
parts)
bulk_forms = initialize_bulk_forms(request, site, parts, bulk_form_attrs)
bulk_delete_form = forms.BulkParticipantDeleteForm(request.POST)
if bulk_delete_form.is_valid():
form_data = get_bulk_form_data(bulk_delete_form, parts)
req_delete_uids = set(form_data["requested_uids"])
existing_uids = set(form_data["existing_uids"])
missing_uids = req_delete_uids - existing_uids
if len(missing_uids) == 0:
for uid in sorted(req_delete_uids):
part = get_participant_by_site_uid(site, uid)
part.delete()
return redirect(site.get_update_url())
ctx = mk_ee_context(
breadcrumbs=create_ee_breadcrumbs(exptr, exp, site),
title="Site Editor",
experimenter=exptr,
experiment=exp,
site=site,
participants=parts,
num_participant_columns=calculate_participant_list_num_cols(parts),
form=forms.SiteForm(instance=site))
ctx.update(bulk_forms)
ctx["bulk_delete_form"] = bulk_delete_form
return render(request,
"django_tutalk/experiment_editor/site_update.html",
ctx)
def promo_code_update(request, pc_id=None):
pk = pk_to_int_or_404(pc_id)
pc = get_object_or_404(models.PromoCode, id=pk)
if "GET" == request.method:
form = forms.PromoCodeForm(instance=pc)
else:
form = forms.PromoCodeForm(request.POST, instance=pc)
if form.is_valid():
pc.save()
return redirect('experiment-editor:index')
ctx = mk_ee_context(
breadcrumbs=create_ee_breadcrumbs(pc),
title="Promo Code Editor",
form=form)
return render(request,
'django_tutalk/experiment_editor/simple_entity_update.html',
ctx)
def parameter_create(request, app_id=None):
pk = pk_to_int_or_404(app_id)
app = get_object_or_404(models.App, id=pk)
if "GET" == request.method:
form = forms.ParameterForm(initial={'app': app.id})
else:
form = forms.ParameterForm(request.POST)
if form.is_valid():
form.save()
return redirect(app.get_update_url())
ctx = mk_ee_context(
breadcrumbs=create_ee_breadcrumbs(app,
{"label": "App Parameter: new"}),
title="New App Parameter",
form=form)
return render(request,
'django_tutalk/experiment_editor/entity_create.html',
ctx)
def experiment_type_update(request, et_id=None):
pk = pk_to_int_or_404(et_id)
exp_type = get_object_or_404(models.ExperimentType, id=pk)
if "GET" == request.method:
form = forms.ExperimentTypeForm(instance=exp_type)
else:
form = forms.ExperimentTypeForm(request.POST, instance=exp_type)
if form.is_valid():
form.save()
return redirect('experiment-editor:index')
ctx = mk_ee_context(
breadcrumbs=create_ee_breadcrumbs(exp_type),
title="Experiment Type Editor",
form=form)
return render(
request,
'django_tutalk/experiment_editor/simple_entity_update.html',
ctx)
def app_update(request, app_id=None):
pk = pk_to_int_or_404(app_id)
app = get_object_or_404(models.App, id=pk)
if "GET" == request.method:
form = forms.AppForm(instance=app)
else:
form = forms.AppForm(request.POST, instance=app)
if form.is_valid():
form.save()
return redirect(app.get_update_url())
ctx = mk_ee_context(
breadcrumbs=create_ee_breadcrumbs(app),
title="App Editor",
create_param=app.get_create_param_url(),
create_cust_param=app.get_create_cust_param_url(),
params=app.params,
cust_params=app.cust_params,
form=form)
return render(request,
'django_tutalk/experiment_editor/app_update.html',
ctx)
def experiment_create(request, exptr_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
if "GET" == request.method:
form = forms.ExperimentForm(initial={"experimenter": exptr})
et_choices = get_experiment_types()
form.fields["experiment_type"].choices = et_choices
else:
form = forms.ExperimentForm(request.POST)
if form.is_valid():
exp = form.save()
return redirect(exp.get_update_url())
ctx = mk_ee_context(
breadcrumbs=create_ee_breadcrumbs(exptr,
{"label": "Experiment: new"}),
title="Create Experiment",
experimenter=exptr,
form=form)
return render(request,
"django_tutalk/experiment_editor/entity_create.html",
ctx)
def experimenter_update(request, exptr_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
if "GET" == request.method:
form = forms.ExperimenterForm(instance=exptr)
choices = get_superuser_staff_emails()
form.fields["owner"].choices = choices
else:
form = forms.ExperimenterForm(request.POST, instance=exptr)
if form.is_valid():
form.save()
return redirect(exptr.get_update_url())
ctx = mk_ee_context(
breadcrumbs=create_ee_breadcrumbs(exptr),
title="Experimenter Editor",
experimenter=exptr,
experiments=exptr.exps,
create_experiment=exptr.get_create_experiment_url(),
form=form)
return render(request,
"django_tutalk/experiment_editor/experimenter_update.html",
ctx)
def task_start(request, part_id=None, task_id=None):
part_id = pk_to_int_or_404(part_id)
task_id = pk_to_int_or_404(task_id)
part = get_object_or_404(models.Participant, pk=part_id)
task = get_object_or_404(models.Task, pk=task_id)
session = request.session
app = task.app
cond = part.condition
site = part.site
exp = site.experiment
exptr = exp.experimenter
# a task's app may not require a scenario, initialize these to null
(scen_id, scen_name) = (None, None)
if task.scenario is not None:
scen_id = task.scenario.id
tmp = task.scenario.scenario_file.name
scen_name = os.path.splitext(os.path.basename(tmp))[0]
# although the tutalk is "localhost" this get's different values in
# different environments, such as when running manage.py runserver
# (no reverse proxy)
# thus the value of tutalk host needs to be computed
server_name = request.META["HTTP_HOST"]
if "HTTP_X_FORWARDED_SERVER" in request.META:
server_name = request.META["HTTP_X_FORWARDED_SERVER"]
server_port = request.META["SERVER_PORT"]
server_name = server_name.replace(server_port, '').rstrip(':')
if server_name.startswith("127.0"):
server_name = "localhost"
tutalk_host = server_name
if "localhost" == tutalk_host:
tutalk_host = socket.getfqdn()
# remove any session information related to any previous
# taks the user may have run
for key in request.session.keys():
if not key.startswith("_auth_user"):
del request.session[key]
std_app_params = build_std_app_params_dict(
cond, exp, exptr, part, site, task, scen_id, scen_name, tutalk_host)
url = "%s" % app.url
if not url.startswith("http"):
url = "http://%s/%s" % (server_name, url)
# map the App's names for app parameters to the actual values
qd = QueryDict(mutable=True)
for param in app.params:
try:
qd[param.name] = std_app_params[param.value]
except KeyError as ke:
utils.LOGGER.error(ke)
# add any custom app param name/values
if len(app.cust_params) > 0:
for cust_param in app.cust_params:
qd[cust_param.name] = cust_param.value
if "session" == app.parameter_method:
for (key, value) in qd.iteritems():
session[key] = value
session.save()
elif "querystring" == app.parameter_method:
qs = "%s" % qd.urlencode()
url = "%s?%s" % (url, qs)
# always save the following information in the session object
# regardless of the apps parameter passing scheme
session["task_info"] = (task_id, part_id)
session.save()
task_status = models.TaskStatus.objects\
.get_or_create(participant_id=part_id,
task_id=task_id)[0]
task_status.set_started()
task_status.save()
return HttpResponseRedirect(url, 302)
def app_delete(request, app_id=None):
pk = pk_to_int_or_404(app_id)
app = get_object_or_404(models.App, id=pk)
app.delete()
return redirect('experiment-editor:index')
def bulk_participant_create(request, exptr_id=None, exp_id=None, site_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
exp_id = pk_to_int_or_404(exp_id)
exp = get_object_or_404(models.Experiment, pk=exp_id)
site_id = pk_to_int_or_404(site_id)
site = get_object_or_404(models.Site, pk=site_id)
parts = site.parts
conds = exp.conds
bulk_form_attrs = get_bulk_form_attributes(site,
parts,
conditions=conds)
bulk_forms = initialize_bulk_forms(request, site, parts, bulk_form_attrs)
bulk_create_form = forms.BulkParticipantCreateForm(request.POST)
if bulk_create_form.is_valid():
form_data = get_bulk_form_data(bulk_create_form,
parts,
conditions=conds)
cond_cycler = form_data["condition_cycler"]
req_create_uids = set(form_data["requested_uids"])
existing_uids = set(form_data["existing_uids"])
pre_existing_uids = existing_uids.intersection(req_create_uids)
if len(pre_existing_uids) == 0:
# conds = [cond_name_cond[cond_name] for cond_name in cond_names]
# cond_name_cycler = itertools.cycle(conds)
for uid in sorted(req_create_uids):
try:
part = models.Participant(
uid=uid,
site=site,
condition=next(cond_cycler))
part.save()
except StopIteration as e:
LOGGER.error(e)
break
# send back to site edit
return redirect(site.get_update_url())
else:
bulk_create_form.add_error(
"first_uid",
ValidationError("uid %d already exists" %
min(pre_existing_uids),
code="invalid"))
bulk_create_form.add_error(
"last_uid",
ValidationError("uid %d already exists" %
max(pre_existing_uids),
code="invalid"))
ctx = mk_ee_context(
breadcrumbs=create_ee_breadcrumbs(exptr, exp, site),
title="Site Editor",
experimenter=exptr,
experiment=exp,
site=site,
participants=parts,
num_participant_columns=calculate_participant_list_num_cols(parts),
form=forms.SiteForm(instance=site))
ctx.update(bulk_forms)
ctx["bulk_create_form"] = bulk_create_form
return render(request,
"django_tutalk/experiment_editor/site_update.html",
ctx)
def experimenter_delete(request, exptr_id=None):
exptr_id = pk_to_int_or_404(exptr_id)
exptr = get_object_or_404(models.Experimenter, pk=exptr_id)
exptr.delete()
return redirect('experiment-editor:index')
def experiment_type_delete(request, et_id=None):
pk = pk_to_int_or_404(et_id)
exp_type = get_object_or_404(models.ExperimentType, id=pk)
exp_type.delete()
return redirect('experiment-editor:index')
