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 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 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 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 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 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 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_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 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 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 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_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 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 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,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):
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_detail(request, meta_id):
session = Session()
meta = session.query(ProblemMeta).get(meta_id)
if meta is None:
raise Http404
descriptions = meta.descriptions
io_datas = meta.input_output_datas
data = {"meta": meta,
"descriptions": descriptions,
"io_datas": io_datas}
for config_refer in meta.get_config_refer():
if hasattr(meta, config_refer):
data.update({config_refer: getattr(meta, config_refer)})
session.close()
return render_to_response('problem/meta_detail.html', data,
context_instance=RequestContext(request))
def description_type_add(request, description_meta_id):
session = Session()
description_meta_object = session.query(DescriptionMeta).get(description_meta_id)
session.close()
if description_meta_object is None:
raise Http404
if request.method == 'POST':
form = DescriptionTypeForm(request.POST)
if form.is_valid():
description_type = form.save(description_meta_id=description_meta_id)
data = {'description_type_id':description_type.id, }
return HttpResponseRedirect(reverse('description_type_item_relation_combine_add', kwargs=data))
else:
form = DescriptionTypeForm()
data = {'form': form, 'description_meta_id':description_meta_id}
return render_to_response("description/description_type_add.html", data, context_instance=RequestContext(request))
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 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, 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
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 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 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, meta_id=None, update=False, object_id=None):
session = Session()
if update:
problem = session.query(Problem).get(int(object_id))
else:
problem = Problem()
problem.problem_meta_id = meta_id
job_list = self.cleaned_data['judge_flow']
flow_mark = ""
for job in job_list:
flow_mark += JUDGE_FLOW_MARK_SEPARATOR + str(job)
problem.judge_flow = flow_mark
session.expire_on_commit = False
if not update:
session.add(problem)
session.commit()
session.close()
return problem
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 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
