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 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 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):
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):
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_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 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 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, 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, update=False,
description_meta_item_relation_combination_id=None,description_meta_id=None,):
description_meta_item_relation_combination_objects = []
for item_relation_id in self.cleaned_data['item_relations']:
obj_dmitrc = DescriptionMetaItemRelationCombination(description_meta_id = description_meta_id,
item_relation_id = item_relation_id,
)
description_meta_item_relation_combination_objects.append(obj_dmitrc)
session = Session()
session.add_all(description_meta_item_relation_combination_objects)
session.commit()
session.close()
return description_meta_id
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, 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 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, 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, 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 save(self, commit=True, meta_id=None, update=False, object_id=None):
session = Session()
if update:
description = session.query(Description).get(int(object_id))
else:
description = Description()
description.problem_meta_id = meta_id
description.title = self.cleaned_data['title']
description.content = self.cleaned_data['content']
description.input = self.cleaned_data['input']
description.output = self.cleaned_data['output']
description.sample_input = self.cleaned_data['sample_input']
description.sample_output = self.cleaned_data['sample_output']
description.hint = self.cleaned_data['hint']
description.source = self.cleaned_data['source']
if not update:
session.add(description)
session.commit()
session.close()
return description
def setter(raw_password):
self.set_password(raw_password)
session = Session()
session.merge(self)
session.commit()
session.close()
def problem_config_edit(request, id):
if request.method == 'POST':
desc_id = request.POST.get("desc_id", None)
if desc_id is not None:
try:
desc_id = int(desc_id)
except:
desc_id = None
session = Session()
problem = session.query(Problem).get(id)
if problem is None:
session.close()
raise Http404
meta_id = problem.problem_meta_id
if desc_id is None:
problem.description = None
else:
description = session.query(Description).\
filter_by(id=desc_id, problem_meta_id=problem.problem_meta_id).first()
problem.description = description
clear_sa_list(problem.input_output_datas)
io_data_post = request.POST.getlist("io_datas", [])
for io_data_id in io_data_post:
io_data = session.query(InputOutputData).\
filter_by(id=int(io_data_id), problem_meta_id=problem.problem_meta_id).first()
if io_data is not None:
problem.input_output_datas.append(io_data)
session.commit()
for config_refer in problem.get_config_refer():
if hasattr(problem.problem_meta, config_refer) and \
hasattr(problem, config_refer):
configs = getattr(problem, config_refer)
clear_sa_list(configs)
configs_post = request.POST.getlist(config_refer, [])
Model = get_model_by_model_ref(config_refer)
for config_id in configs_post:
config = session.query(Model).\
filter_by(id=int(config_id), problem_meta_id=problem.problem_meta_id).first()
if config is not None:
configs.append(config)
session.commit()
session.commit()
session.close()
return HttpResponseRedirect(reverse('meta_detail', kwargs={'meta_id': meta_id}))
else:
session = Session()
problem = session.query(Problem).get(id)
if problem is None:
session.close()
raise Http404
if problem.description is not None:
desc_id = problem.description.id
else:
desc_id = -1
meta_descs = problem.problem_meta.descriptions
meta_io_datas = problem.problem_meta.input_output_datas
io_datas_id = [data.id for data in problem.input_output_datas]
data = {'problem':problem,
'desc_id':desc_id,
'meta_descs':meta_descs,
'io_datas_id': io_datas_id,
'meta_io_datas': meta_io_datas,
}
for config_refer in problem.get_config_refer():
if hasattr(problem.problem_meta, config_refer):
data.update({config_refer: getattr(problem.problem_meta, config_refer)})
if hasattr(problem, config_refer):
data.update({config_refer+"_id": [ c.id for c in getattr(problem, config_refer)]})
session.close()
return render_to_response("problem/problem_config_edit.html", data, context_instance=RequestContext(request))
