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 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 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, update=False,description_type_id=None,):
description_type_item_relation_combination_objects = []
choice_list = []
for obj in self.form_info_list:
field_info_list = self.cleaned_data[obj.title_field_name].split(',')
choice_list.append(field_info_list[0])
if field_info_list[0] == 'True' :
if field_info_list[1] != 'None' and field_info_list[2] != 'None':
# description_type_item_relation_combination --> obj_dtitrc
obj_dtitrc = DescriptionTypeItemRelationCombination(description_type_id = description_type_id,
item_relation_id = obj.item_relation_id,
multi_number = int(field_info_list[1]),
show_order = int(field_info_list[2]),
relation_items_number = obj.relation_items_number,
)
description_type_item_relation_combination_objects.append(obj_dtitrc)
else:
return None
if not 'True' in choice_list:
return None
session = Session()
session.add_all(description_type_item_relation_combination_objects)
session.commit()
session.close()
return description_type_id
def save(self, commit=True, update=False,item_relation_combination_id=None,item_relation_id=None,):
item_relation_combination_objects = []
choice_list = []
for item_info in self.item_info_list:
field_info_list = self.cleaned_data[item_info.title_field_name].split(',')
choice_list.append(field_info_list[0])
if field_info_list[0] == 'True' :
if field_info_list[1] != 'None' and field_info_list[2] != 'None':
item_relation_combination = ItemRelationCombination(item_id = item_info.item_id,
item_relation_id = item_relation_id,
combination_number = int(field_info_list[1]),
show_order = int(field_info_list[2]),
)
item_relation_combination_objects.append(item_relation_combination)
else:
return None
if not 'True' in choice_list:
return None
session = Session()
session.add_all(item_relation_combination_objects)
session.commit()
session.close()
return item_relation_id
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 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 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, commit=True):
user = User()
user.username = self.cleaned_data["username"]
user.set_password(self.cleaned_data["password1"])
user.is_active = True
session = Session()
session.add(user)
session.commit()
session.close()
return user
def update_last_login(sender, user, **kwargs):
"""
A signal receiver which updates the last_login date for
the user logging in.
"""
user.last_login = timezone.now()
session = Session()
session.merge(user)
session.commit()
session.close()
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 save(self, commit=True, meta_id=None):
keyword_check_config = KeywordCheckConfig()
keyword_check_config.problem_meta_id = meta_id
keyword_check_config.code_type = self.cleaned_data['code_type']
keyword_check_config.word = self.cleaned_data['word']
session = Session()
session.add(keyword_check_config)
session.commit()
session.close()
return keyword_check_config
def save(self, commit=True, meta_id=None):
compilable_code_generation_config = CompilableCodeGenerationConfig()
compilable_code_generation_config.problem_meta_id = meta_id
compilable_code_generation_config.code_type = self.cleaned_data['code_type']
compilable_code_generation_config.generation_method = self.cleaned_data['generation_method']
compilable_code_generation_config.requirement = self.cleaned_data['requirement']
session = Session()
session.add(compilable_code_generation_config)
session.commit()
session.close()
return compilable_code_generation_config
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 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 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 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 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 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 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 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 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 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
