def description_meta_item_relation_combine_add(request,description_meta_id):
session = Session()
item_relation_objects = session.query(ItemRelation).all()
description_meta_object = session.query(DescriptionMeta).get(description_meta_id)
session.close()
if description_meta_object is None:
raise Http404
item_relation_choice = [(obj.id,obj.title) for obj in item_relation_objects]
initial={"item_relation_choice":item_relation_choice,}
if request.method == 'POST':
form = DescriptionMetaItemRelationCombinationForm(request.POST,initial=initial,auto_id=False)
if form.is_valid():
id = form.save(description_meta_id = description_meta_id)
if id is not None:
data = {'template':'description/description_meta_list.html',
'ItemClass':DescriptionMeta,
'page':1,
}
return HttpResponseRedirect(reverse('description_meta_list', kwargs=data))
else:
form = DescriptionMetaItemRelationCombinationForm(initial=initial,auto_id=False)
data = {'form': form,'description_meta_object':description_meta_object}
return render_to_response("description/description_meta_item_relation_combine_add.html", data, context_instance=RequestContext(request))
def description_type_detail(request,description_type_id):
session = Session()
description_type_object = session.query(DescriptionType).get(description_type_id)
description_meta_object = session.query(DescriptionMeta).get(description_type_object.description_meta_id)
if description_type_object is None or description_meta_object is None:
raise Http404
objs_in_relation = session.query(DescriptionTypeItemRelationCombination).\
filter(DescriptionTypeItemRelationCombination.description_type_id == description_type_id).\
order_by(DescriptionTypeItemRelationCombination.show_order)
description_type_item_relation_detail_object_list = []
for obj in objs_in_relation:
item_relation_object = session.query(ItemRelation).get(obj.item_relation_id)
item_relation_detail_object = DescriptionTypeItemRelationViewDetail(item_relation_id = item_relation_object.id,
item_relation_title = item_relation_object.title,
multi_number = obj.multi_number,
show_order = obj.show_order,
)
description_type_item_relation_detail_object_list.append(item_relation_detail_object)
session.close()
data = {'description_type_object':description_type_object,
'description_meta_object':description_meta_object,
'detail_list':description_type_item_relation_detail_object_list}
return render_to_response("description/description_type_detail.html", data, context_instance=RequestContext(request))
def item_relation_combine_add(request,item_relation_id):
session = Session()
item_objects = session.query(Item).all()
item_relation_object = session.query(ItemRelation).get(item_relation_id)
session.close()
if item_relation_object is None:
raise Http404
item_info_list = []
for item in item_objects:
item_info_object = ItemRelationCombinationFormInfo(item_id=item.id,item_title=item.title)
item_info_list.append(item_info_object)
initial={"item_info_list":item_info_list,}
if request.method == 'POST':
form = ItemRelationCombinationForm(request.POST,initial=initial,auto_id=False)
if form.is_valid():
id = form.save(item_relation_id = item_relation_id)
if id is not None:
data = {'template':'description/item_relation_list.html',
'ItemClass':ItemRelation,
'page':1,
}
return HttpResponseRedirect(reverse('item_relation_list', kwargs=data))
else:
form = ItemRelationCombinationForm(initial=initial,auto_id=False)
data = {'form': form,'item_relation_id':item_relation_id}
return render_to_response("description/item_relation_combine_add.html", data, context_instance=RequestContext(request))
def save(self, commit=True):
self.user.set_password(self.cleaned_data['new_password1'])
if commit:
session = Session()
session.query(User).filter_by(id=self.user.id).update({"password": self.user.password})
session.commit()
session.close()
return self.user
def save(self, commit=True, update=False,item_id=None):
session = Session()
if update:
item = session.query(Item).get(item_id)
else:
item = Item()
item.title = self.cleaned_data['title']
if not update:
session.add(item)
session.commit()
item.id = item.id
#新建一个item 自动新建一个关系 和一个组合
item_relation = ItemRelation(title = item.title)
session.add(item_relation)
session.commit()
item_relation.id = item_relation.id
item_relation_combination = ItemRelationCombination(item_id =item.id,
item_relation_id = item_relation.id,
combination_number = 1,
show_order = 1,
)
session.add(item_relation_combination)
session.commit()
session.close()
return item
def description_type_item_relation_combine_add(request,description_type_id):
session = Session()
description_type_object = session.query(DescriptionType).get(description_type_id)
if description_type_object is None:
raise Http404
description_meta_id = description_type_object.description_meta_id
description_meta_object = session.query(DescriptionMeta).get(description_meta_id)
if description_meta_object is None:
raise Http404
objs_in_relation = session.query(DescriptionMetaItemRelationCombination).filter(DescriptionMetaItemRelationCombination.description_meta_id == description_meta_id)
form_info_list = []
for obj in objs_in_relation:
item_relation_object = session.query(ItemRelation).get(obj.item_relation_id)
objs_in_relation_combination = session.query(ItemRelationCombination).filter(ItemRelationCombination.item_relation_id == item_relation_object.id)
relation_items_number = 0
for o in objs_in_relation_combination:
relation_items_number += o.combination_number
form_info_obj = DescriptionMetaItemRelationCombinationFormInfo(item_relation_id = item_relation_object.id,
item_relation_title = item_relation_object.title,
relation_items_number = relation_items_number
)
form_info_list.append(form_info_obj)
session.close()
initial={"form_info_list":form_info_list,}
if request.method == 'POST':
form = DescriptionTypeItemRelationCombinationForm(request.POST,initial=initial,auto_id=False)
if form.is_valid():
id = form.save(description_type_id = description_type_id)
if id is not None:
data = {'description_meta_id':description_meta_id,'page':1}
return HttpResponseRedirect(reverse('description_type_list', kwargs=data))
else:
form = DescriptionTypeItemRelationCombinationForm(initial=initial,auto_id=False)
data = {'form': form,'description_type_id':description_type_id}
return render_to_response("description/description_type_item_relation_combine_add.html", data, context_instance=RequestContext(request))
def meta_delete(request, meta_id):
session = Session()
meta = session.query(ProblemMeta).get(int(meta_id))
session.delete(meta)
session.commit()
session.close()
return HttpResponseRedirect(reverse('meta_list', kwargs={'page': 1}))
def description_type_list(request, description_meta_id, page=1):
session = Session()
description_meta_object = session.query(DescriptionMeta).get(description_meta_id)
session.close()
if description_meta_object is None:
raise Http404
description_type_objects = session.query(DescriptionType).filter(DescriptionType.description_meta_id == description_meta_id)
paginator = Paginator(description_type_objects, settings.METAS_PER_PAGE)
try:
objects = paginator.page(description_type_objects)
except (EmptyPage, InvalidPage):
objects = paginator.page(paginator.num_pages)
data = {"objects": objects,"description_meta_object":description_meta_object}
return render_to_response("description/description_type_list.html", data,
context_instance=RequestContext(request))
def problem_detail(request, prob_id):
session = Session()
prob = session.query(Problem).get(int(prob_id))
if prob is None:
session.close()
raise Http404
res = render_to_response('problem/problem_detail.html', {"prob": prob},
context_instance=RequestContext(request))
session.close()
return res
def authenticate(self, username=None, password=None):
session = Session()
user = session.query(User).filter_by(username=username).first()
if user is not None:
if not user.check_password(password):
user = None
session.close()
return user
def save(self, problem=None, user=None):
if problem is None:
return
sub = Submission()
sub.status = STATUS.pending
sub.problem_id = problem.id
sub.code_type = self.cleaned_data["code_type"]
sub.code = self.cleaned_data["code_text"]
sub.user = user
sub.length = len(sub.code)
session = Session()
session.query(Problem).filter_by(id = problem.id).update({"submit": Problem.submit+1})
session.query(User).filter_by(id = user.id).update({"submit": User.submit+1})
session.add(sub)
session.commit()
self.handle_code(sub, self.cleaned_data["code_file"])
session.close()
return sub
def item_relation_detail(request,item_relation_id):
session = Session()
item_relation_object = session.query(ItemRelation).get(item_relation_id)
items_in_relation = session.query(ItemRelationCombination).filter(ItemRelationCombination.item_relation_id == item_relation_id)
item_relation_detail_object_list = []
for i_in_relation in items_in_relation:
item_object = session.query(Item).get(i_in_relation.item_id)
item_relation_detail_object = ItemRelationViewDetail(item_id = item_object.id,
item_title=item_object.title,
combination_number = i_in_relation.combination_number,
show_order = i_in_relation.show_order,
)
item_relation_detail_object_list.append(item_relation_detail_object)
session.close()
if item_relation_object is None:
raise Http404
data = {'item_relation_object':item_relation_object,'detail_list':item_relation_detail_object_list}
return render_to_response("description/item_relation_detail.html", data, context_instance=RequestContext(request))
def meta_config_detail(request, detailClass, object_id, template):
session = Session()
object_detail = session.query(detailClass).get(int(object_id))
if object_detail is None:
session.close()
raise Http404
res = render_to_response(template, {"object_detail": object_detail},
context_instance=RequestContext(request))
session.close()
return res
def clean_username(self):
# Since User.username is unique, this check is redundant,
# but it sets a nicer error message than the ORM. See #13147.
username = self.cleaned_data["username"]
session = Session()
c_users = session.query(User).filter_by(username=username).count()
session.close()
if c_users > 0:
raise forms.ValidationError(self.error_messages['duplicate_username'])
else:
return username
def meta_list(request, page=1):
session = Session()
metas_all = session.query(ProblemMeta).all()
session.close()
paginator = Paginator(metas_all, settings.METAS_PER_PAGE)
try:
metas = paginator.page(metas_all)
except (EmptyPage, InvalidPage):
metas = paginator.page(paginator.num_pages)
return render_to_response('problem/meta_list.html', {"metas": metas},
context_instance=RequestContext(request))
def meta_config_edit(request, configForm, editObjectClass, meta_id, object_id,
template_name=None, redirect_to=None):
session = Session()
meta = session.query(ProblemMeta).get(meta_id)
if request.method == 'POST':
request.POST.update({"problem_meta_id":meta_id})
form = configForm(request.POST, request.FILES)
if form.is_valid():
obj = form.save(meta_id=meta_id, update=True, object_id=object_id)
if redirect_to is None:
res = HttpResponseRedirect(reverse('meta_detail', kwargs={'meta_id': meta_id}))
else:
res = HttpResponseRedirect(reverse(redirect_to, kwargs={'id': obj.id}))
session.close()
return res
else:
session = Session()
object_detail = session.query(editObjectClass).get(int(object_id))
if object_detail is None:
session.close()
raise Http404
edit_object_class_attrs = [attr for attr in editObjectClass.__dict__ if attr[0] != '_']
initial_data = {}
for attr in edit_object_class_attrs:
initial_data[attr] = getattr(object_detail,attr)
form = configForm(initial=initial_data)
res = render_to_response(template_name, {
'form': form, "meta":meta},
context_instance=RequestContext(request))
session.close()
return res
def show_list(request, template, ItemClass, page=1):
session = Session()
objects_all = session.query(ItemClass).all()
session.close()
paginator = Paginator(objects_all, settings.METAS_PER_PAGE)
try:
objects = paginator.page(objects_all)
except (EmptyPage, InvalidPage):
objects = paginator.page(paginator.num_pages)
data = {"objects": objects}
return render_to_response(template, data,
context_instance=RequestContext(request))
def submit(request, prob_id):
session = Session()
prob = session.query(Problem).get(int(prob_id))
if request.method == "POST":
form = SubmissionForm(request.POST, request.FILES)
if form.is_valid():
form.save(problem=prob, user=request.user)
return HttpResponseRedirect(reverse('status', kwargs={'page': 1}))
else:
form = SubmissionForm()
res = render_to_response('problem/submit.html', {"prob": prob, "form": form},
context_instance=RequestContext(request))
session.close()
return res
def meta_config_delete(request, deleteObjectClass, meta_id, object_id):
session = Session()
object_delete = session.query(deleteObjectClass).get(int(object_id))
if object_delete is None:
session.close()
raise Http404
if hasattr(object_delete, "on_delete"):
object_delete.on_delete()
session.delete(object_delete)
session.commit()
session.close()
return HttpResponseRedirect(reverse('meta_detail', kwargs={'meta_id': meta_id}))
def problem_list_admin(request, page=1):
session = Session()
prob_all = session.query(Problem).all()
paginator = Paginator(prob_all, settings.METAS_PER_PAGE)
try:
probs = paginator.page(prob_all)
except (EmptyPage, InvalidPage):
probs = paginator.page(paginator.num_pages)
res = render_to_response('problem/problem_list_admin.html', {"probs": probs},
context_instance=RequestContext(request))
session.close()
return res
def status(request, page=1):
session = Session()
sub_all = session.query(Submission).order_by(Submission.sub_time.desc())
paginator = Paginator(sub_all, 100)#settings.METAS_PER_PAGE)
try:
subs = paginator.page(sub_all)
except (EmptyPage, InvalidPage):
subs = paginator.page(paginator.num_pages)
res = render_to_response('problem/status_list.html', {"subs": subs},
context_instance=RequestContext(request))
session.close()
return res
def save(self, commit=True, meta_id=None, update=False, object_id=None):
session = Session()
if update:
output_check_config = session.query(OutputCheckConfig).get(int(object_id))
else:
output_check_config = OutputCheckConfig()
output_check_config.problem_meta_id = meta_id
output_check_config.check_method = self.cleaned_data['check_method']
if not update:
session.add(output_check_config)
session.commit()
session.close()
return output_check_config
def clean_email(self):
"""
Validates that an active user exists with the given email address.
"""
email = self.cleaned_data["email"]
session = Session()
self.users_cache = session.query(User).filter_by(email=email,
is_active=True)
session.close()
if not len(self.users_cache):
raise forms.ValidationError(self.error_messages['unknown'])
if any((user.password == UNUSABLE_PASSWORD)
for user in self.users_cache):
raise forms.ValidationError(self.error_messages['unusable'])
return email
def meta_edit(request, meta_id):
session = Session()
meta = session.query(ProblemMeta).get(meta_id)
if meta is None:
session.close()
raise Http404
if request.method == "POST":
form = ProblemMetaForm(request.POST)
if form.is_valid():
meta = form.save(update=True, meta_id=meta_id)
return HttpResponseRedirect(reverse('meta_detail', kwargs={'meta_id': meta.id}))
else:
form = ProblemMetaForm(initial={"title":meta.title, "judge_flow":meta.judge_flow})
data = {'form': form}
return render_to_response("problem/problem_meta_edit.html", data, context_instance=RequestContext(request))
def save(self, commit=True, meta_id=None, update=False, object_id=None):
session = Session()
if update:
compile_config = session.query(CompileConfig).get(int(object_id))
else:
compile_config = CompileConfig()
compile_config.problem_meta_id = meta_id
compile_config.code_type = self.cleaned_data['code_type']
compile_config.config = self.cleaned_data['config']
if not update:
session.add(compile_config)
session.commit()
session.close()
return compile_config
def save(self, commit=True, update=False,item_relation_id=None):
session = Session()
if update:
item_relation = session.query(ItemRelation).get(item_relation_id)
else:
item_relation = ItemRelation()
item_relation.title = self.cleaned_data['title']
if not update:
session.add(item_relation)
session.commit()
item_relation.id = item_relation.id
session.close()
return item_relation
def save(self, commit=True, update=False,description_meta_id=None):
session = Session()
if update:
description_meta = session.query(DescriptionMeta).get(description_meta_id)
else:
description_meta = DescriptionMeta()
description_meta.title = self.cleaned_data['title']
if not update:
session.add(description_meta)
session.commit()
description_meta.id = description_meta.id
session.close()
return description_meta
def save(self, commit=True, meta_id=None, update=False, object_id=None):
session = Session()
if update:
run_config = session.query(RuntimeConfig).get(int(object_id))
else:
run_config = RuntimeConfig()
run_config.problem_meta_id = meta_id
run_config.code_type = self.cleaned_data['code_type']
run_config.memory = self.cleaned_data['memory']
run_config.time = self.cleaned_data['time']
if not update:
session.add(run_config)
session.commit()
session.close()
return run_config
def save(self, commit=True, meta_id=None, update=False, object_id=None):
session = Session()
if update:
input_output_data = session.query(InputOutputData).get(int(object_id))
else:
input_output_data = InputOutputData()
input_output_data.problem_meta_id = meta_id
input_output_data.name = self.cleaned_data['name']
input_file = self.cleaned_data['input_file']
output_file = self.cleaned_data['output_file']
if not update:
session.add(input_output_data)
session.commit()
save_io_file(input_file, output_file, input_output_data, update)
session.close()
return input_output_data
def save(self, commit=True, update=False, meta_id=0):
session = Session()
if update:
problem_meta = session.query(ProblemMeta).get(meta_id)
else:
problem_meta = ProblemMeta()
problem_meta.title = self.cleaned_data['title']
job_list = ""
for job in self.cleaned_data['judge_flow']:
job_list += JUDGE_FLOW_MARK_SEPARATOR + job
problem_meta.judge_flow = job_list
session.expire_on_commit = False
if not update:
session.add(problem_meta)
session.commit()
session.close()
return problem_meta
