def create_job(user_id):
"""Used by users to create job posts"""
if not g.user:
flash("Access unauthorized.", "danger")
return redirect("/")
if g.user and session[CURR_USER_KEY] == user_id:
genres = Genre.query.all()
regions = Region.query.all()
# list of tuples for selectfield
region_list = [(i.id, i.city) for i in regions]
genre_list = [(j.id, j.genre) for j in genres]
form = JobForm()
#passing selectfield choice into the form
form.region_id.choices = region_list
form.genre_id.choices = genre_list
if form.validate_on_submit():
job = JobPost(title=form.title.data,
description=form.description.data,
pay=form.pay.data,
date=form.date.data,
region_id=form.region_id.data,
user_id=user_id,
genre_id=form.genre_id.data)
db.session.add(job)
db.session.commit()
return redirect(f"/users/{user_id}")
return render_template("jobs/job-form.html", form=form)
else:
flash("Access unauthorized.", "danger")
return redirect("/")
def add_job(request):
try:
form = JobForm(request.POST or None)
if form.is_valid():
required_skills = set(form.cleaned_data["required_skills"])
optional_skills = set(form.cleaned_data["optional_skills"]) - required_skills
with transaction.atomic():
employer = Employer.objects.get(user=request.user)
job = Job(
employer=employer,
description=form.cleaned_data["description"],
category=form.cleaned_data["category"],
years_of_experience=form.cleaned_data["years_of_experience"],
other=form.cleaned_data["other"],
)
job.save()
for skill in required_skills:
skill = RequiredJobSkill(job=job, skill=skill)
skill.save()
if optional_skills:
for skill in optional_skills:
skill = OptionalJobSkill(job=job, skill=skill)
skill.save()
match_job.delay(job.id)
messages.success(request, "Job saved successfully. You'll receive matching candidates soon")
return HttpResponseRedirect("/")
return render(request, "jobs/add_job.html", {"form": form})
except Exception, e:
logging.exception(e)
return server_error(request)
def create_job(request, job_code=None, template = 'job/edit_job.html'):
jobForm = None
JobLocationInlineFormSet = inlineformset_factory(Job, JobLocation, max_num=1, extra=1)
if request.method == 'POST':
jobForm = JobForm(data=request.POST, user=request.user)
if jobForm.is_valid():
job = jobForm.save(commit=False)
formset = JobLocationInlineFormSet(data=request.POST, instance=job)
if formset.is_valid:
job = jobForm.save()
formset.save()
job_created.send(sender=job.__class__, job=job)
return redirect(reverse('employer_dashboard'))
else:
formset = JobLocationInlineFormSet(data=request.POST)
formset.is_valid
else:
jobForm = JobForm(user=request.user)
employer = EmployerProfile.objects.get(user=request.user)
formset = JobLocationInlineFormSet()
for subform in formset:
subform.initial = {
'business_name': employer.business_name,
'business_address1': employer.business_address1,
'business_address2': employer.business_address2,
'city': employer.city,
'zip_code': employer.zip_code,
}
return render_to_response(template,
{'form' : jobForm,
'formset' : formset, } ,
context_instance=RequestContext(request))
def new_job():
form = JobForm()
if form.validate_on_submit():
session = db_session.create_session()
job = Jobs()
job.job = form.title.data
job.team_leader = form.leader_id.data
job.work_size = form.work_size.data
job.collaborators = form.collaborators.data
job.is_finished = form.is_finished.data
job.creator = current_user.id
category_id = form.category.data
category = session.query(CategoryJob).filter(
CategoryJob.id == category_id).first()
job.categories.append(category)
session.commit()
try:
current_user.jobs.append(job)
except:
pass
session.merge(current_user)
session.commit()
return redirect('/')
return render_template('new_job.html', title='New job', form=form)
def add_job():
form = JobForm()
if form.validate_on_submit():
session = db_session.create_session()
job = Jobs()
job.job = form.title.data
job.team_leader = form.leader_id.data
job.work_size = form.work_size.data
job.collaborators = form.collaborators.data
job.is_finished = form.is_finished.data
job.creator = current_user.id
category_id = form.category.data
category = session.query(CategoryJob).filter(
CategoryJob.id == category_id).first()
job.categories.append(category)
session.commit()
try:
current_user.jobs.append(job)
except sqlalchemy.orm.exc.DetachedInstanceError:
pass
except sqlalchemy.exc.InvalidRequestError:
pass
session.merge(current_user)
session.commit()
return redirect('/')
return render_template('add_job.html', title='Adding a job', form=form)
def job(request, profile_id):
if request.method == "POST":
form = JobForm(request.POST, request.FILES)
if form.is_valid():
# found_user = Profile.objects.get(psrn=profile_id)
a = form.save()
a.psrn = profile_id
print "yo"
a.save()
aform = AcadsForm()
args = {}
args.update(csrf(request))
args["form"] = aform
args["profile_id"] = profile_id
return render_to_response("acads.html", args)
else:
form = JobForm()
args = {}
args.update(csrf(request))
args["form"] = form
args["profile_id"] = profile_id
return render_to_response("job.html", args)
def post(self, request, *args, **kwargs):
form = JobForm(request.POST, request.FILES)
if form.is_valid():
now = datetime.datetime.now()
name = request.POST['name']
description = request.POST['description']
interval = request.POST['interval']
interval_options = request.POST['interval_options']
arguments = request.POST['arguments']
active = False
try:
request.POST['active']
active = True
except:
pass
file = request.FILES['file']
file_content = file.read()
file_name = str(now.year) + str(now.month) + str(now.day) + str(now.hour) + str(now.minute) + str(now.second) + str(now.microsecond) + name.replace(' ', '-') + '.py'
f = open(BASE_DIR + '/job_files/' + file_name, 'w')
f.write(file_content)
f.close()
#Save job
new_job = Job(name=name, description=description, interval=interval, interval_options=interval_options, arguments=arguments, active=active, file_name=file_name)
new_job.save()
res = 'Job created'
return render_to_response(self.template_name, locals(), context_instance=RequestContext(request))
def edit_job(request, job_code, template = 'job/edit_job.html'):
form = None
job = Job.objects.get(job_code=job_code)
JobLocationInlineFormSet = inlineformset_factory(Job, JobLocation, max_num=1, extra=1)
''' Check if user has permission to edit this job '''
if job.employer.user != request.user:
redirect(view_job, job_code)
if request.method == 'POST':
form = JobForm(data=request.POST, user=request.user, instance=job)
formset = JobLocationInlineFormSet(data=request.POST, instance=job)
if formset.is_valid():
formset.save()
if form.is_valid():
job = form.save()
return redirect(reverse('employer_dashboard'))
else:
form = JobForm(instance=job, user=request.user)
formset = JobLocationInlineFormSet(instance=job)
return render_to_response(template,
{'form' : form,
'formset': formset,
'job_code' : job_code},
context_instance=RequestContext(request))
def add(request):
#########################################################################################
# 用户操作行为安全保护
# 计时器
timer = time.time() - request.session.get('time_stamp', 0)
# 危险操作次数
action_times = request.session.get('action_times', 0)
# 错误次数是否大于最大
if action_times >= 1:
if not check_verify(request):
return render('verify.html',
locals(),
context_instance=RequestContext(request))
else:
# 重置标志位
reset(request)
#########################################################################################
current_page = 'jobs'
# 检查用户选择的城市是否存在
if check_city(request.GET.get('city_name', False)):
request.session['job_city'] = request.GET.get('city_name')
else:
return index(request=request)
# 打印表单
if request.method == 'GET':
form = JobForm()
return render('jobs_add.html',
locals(),
context_instance=RequestContext(request))
# 处理提交数据
form = JobForm(request.POST)
if form.is_valid():
data = form.cleaned_data
new_job = Job()
new_job.title = data['title']
new_job.city = request.session.get('job_city', '北京')
new_job.company = data['company']
new_job.website = data['website']
new_job.email = data['email']
new_job.content = data['content']
try:
new_job.save()
except Exception, e:
return HttpResponse('保存招聘信息时出现错误：' + str(e))
else:
set(request)
msg = '提交成功，正在等待管理员审核...'
# 发送信号
new_job_was_post.send(sender=new_job.__class__, job=new_job)
return render('posted.html',
locals(),
context_instance=RequestContext(request))
def add(request):
#########################################################################################
# 用户操作行为安全保护
# 计时器
timer = time.time() - request.session.get('time_stamp',0)
# 危险操作次数
action_times = request.session.get('action_times',0)
# 错误次数是否大于最大
if action_times >= 1:
if not check_verify(request):
return render('verify.html',locals(),context_instance=RequestContext(request))
else:
# 重置标志位
reset(request)
#########################################################################################
current_page = 'jobs'
# 检查用户选择的城市是否存在
if check_city(request.GET.get('city_name',False)):
request.session['job_city'] = request.GET.get('city_name')
else:
return index(request=request)
# 打印表单
if request.method == 'GET':
form = JobForm()
return render('jobs_add.html',locals(),context_instance=RequestContext(request))
# 处理提交数据
form = JobForm(request.POST)
if form.is_valid():
data = form.cleaned_data
new_job = Job()
new_job.title = data['title']
new_job.city = request.session.get('job_city','北京')
new_job.company = data['company']
new_job.website = data['website']
new_job.email = data['email']
new_job.content = data['content']
try:
new_job.save()
except Exception,e:
return HttpResponse('保存招聘信息时出现错误：'+str(e))
else:
set(request)
msg = '提交成功，正在等待管理员审核...'
# 发送信号
new_job_was_post.send(
sender = new_job.__class__,
job = new_job
)
return render('posted.html',locals(),context_instance=RequestContext(request))
def edit(job_id):
job_obj = Job.query.get_or_404(job_id)
if job_obj.company_id != current_user.id and not current_user.is_admin():
abort(404)
form = JobForm(obj=job_obj)
if form.validate_on_submit():
form.update_job(job_obj)
flash('职位更新成功', 'success')
return redirect_job_index()
return render_template('job/edit.html', form=form, job_id=job_id)
def index():
form = JobForm()
if request.method == "POST" and form.validate_on_submit():
obj = create_request(**form.data)
flash('Application has been added successfully')
if obj:
return redirect(url_for('content_list'))
return render_template('index.html', **locals())
print "+++++", form.errors
def get(self, request, request_job_id):
'''
Method for getting a Job based on the id provided.
'''
params = dict((key, val) for key, val in request.QUERY_PARAMS.iteritems())
params['request_job_id'] = request_job_id
form = JobForm(params)
if not form.is_valid():
raise BadRequestException()
return Response(form.submit(request))
def get(self, request, request_job_id):
'''
Method for getting a Job based on the id provided.
'''
params = dict(
(key, val) for key, val in request.QUERY_PARAMS.iteritems())
params['request_job_id'] = request_job_id
form = JobForm(params)
if not form.is_valid():
raise BadRequestException()
return Response(form.submit(request))
def edit_job(id):
form = JobForm()
if request.method == "GET":
session = db_session.create_session()
if current_user.id == 1:
job = session.query(Jobs).filter(Jobs.id == id).first()
else:
job = session.query(Jobs).filter(
Jobs.id == id, Jobs.creator == current_user.id).first()
if job:
form.title.data = job.job
form.leader_id.data = job.team_leader
form.work_size.data = job.work_size
form.collaborators.data = job.collaborators
form.is_finished.data = job.is_finished
form.category.data = job.categories[0].id
else:
abort(404)
if form.validate_on_submit():
session = db_session.create_session()
if current_user.id == 1:
job = session.query(Jobs).filter(Jobs.id == id).first()
else:
job = session.query(Jobs).filter(
Jobs.id == id, Jobs.creator == current_user.id).first()
if job:
job.job = form.title.data
job.team_leader = form.leader_id.data
job.work_size = form.work_size.data
job.collaborators = form.collaborators.data
job.is_finished = form.is_finished.data
category_id = form.category.data
category = session.query(CategoryJob).filter(
CategoryJob.id == category_id).first()
job.categories[0] = category
session.commit()
try:
current_user.jobs.append(job)
except sqlalchemy.orm.exc.DetachedInstanceError:
pass
except sqlalchemy.exc.InvalidRequestError:
pass
session.commit()
return redirect('/')
else:
abort(404)
return render_template('add_job.html', title='Job edit', form=form)
def add_jobs(request):
emp = employee.get_employee_by_user(userid=request.user.id)
if request.method == 'POST':
form = JobForm(request.POST, cid=emp.company.id)
if form.is_valid():
try:
job = form.save()
return render(request, 'job_detail.html', {'job': job})
except Exception as ex:
print ex
else:
form = JobForm(cid=emp.company.id)
return render(
request,
'add_job.html',
{'form': form, 'cid': emp.company.id, 'eid': emp.id})
def multi_molecule(request, string):
if request.REQUEST.get("random"):
amount = int(request.REQUEST.get("random"))
string = ','.join(name_expansion(string, rand=amount))
job_form = JobForm.get_form(request, "{{ name }}")
mol_form = MoleculeForm(request.REQUEST)
job_is_valid = job_form.is_valid(request.method)
mol_is_valid = mol_form.is_valid()
if job_is_valid and mol_is_valid:
return job_form.get_results(request, string, mol_form)
elif request.is_ajax():
job_form_html = render_crispy_form(job_form,
context=RequestContext(request))
mol_form_html = render_crispy_form(mol_form,
context=RequestContext(request))
a = {
"success": False,
"job_form_html": job_form_html,
"mol_form_html": mol_form_html,
}
return HttpResponse(json.dumps(a), content_type="application/json")
c = {
"pagename": string,
"job_form": job_form,
"mol_form": MoleculeForm(),
"gjf": "checked",
"autoflip": request.REQUEST.get("autoflip"),
}
return render(request, "chem/multi_molecule.html", c)
def molecule_detail(request, molecule):
job_form = JobForm.get_form(request, molecule)
mol_form = MoleculeForm(request.REQUEST)
job_is_valid = job_form.is_valid(request.method)
mol_is_valid = mol_form.is_valid()
if job_is_valid and mol_is_valid:
return job_form.get_results(request, molecule, mol_form)
elif request.is_ajax():
job_form_html = render_crispy_form(job_form,
context=RequestContext(request))
mol_form_html = render_crispy_form(mol_form,
context=RequestContext(request))
a = {
"success": False,
"job_form_html": job_form_html,
"mol_form_html": mol_form_html,
}
return HttpResponse(json.dumps(a), content_type="application/json")
a = get_molecule_info_status(molecule)
a["job_form"] = job_form
a["mol_form"] = MoleculeForm()
return render(request, "chem/molecule_detail.html", a)
def multi_molecule(request, string):
if request.REQUEST.get("random"):
amount = int(request.REQUEST.get("random"))
string = ','.join(name_expansion(string, rand=amount))
job_form = JobForm.get_form(request, "{{ name }}")
mol_form = MoleculeForm(request.REQUEST)
job_is_valid = job_form.is_valid(request.method)
mol_is_valid = mol_form.is_valid()
if job_is_valid and mol_is_valid:
return job_form.get_results(request, string, mol_form)
elif request.is_ajax():
job_form_html = render_crispy_form(
job_form, context=RequestContext(request))
mol_form_html = render_crispy_form(
mol_form, context=RequestContext(request))
a = {
"success": False,
"job_form_html": job_form_html,
"mol_form_html": mol_form_html,
}
return HttpResponse(json.dumps(a), content_type="application/json")
c = {
"pagename": string,
"job_form": job_form,
"mol_form": MoleculeForm(),
"gjf": "checked",
"autoflip": request.REQUEST.get("autoflip"),
}
return render(request, "chem/multi_molecule.html", c)
def molecule_detail(request, molecule):
job_form = JobForm.get_form(request, molecule)
mol_form = MoleculeForm(request.REQUEST)
job_is_valid = job_form.is_valid(request.method)
mol_is_valid = mol_form.is_valid()
if job_is_valid and mol_is_valid:
return job_form.get_results(request, molecule, mol_form)
elif request.is_ajax():
job_form_html = render_crispy_form(
job_form, context=RequestContext(request))
mol_form_html = render_crispy_form(
mol_form, context=RequestContext(request))
a = {
"success": False,
"job_form_html": job_form_html,
"mol_form_html": mol_form_html,
}
return HttpResponse(json.dumps(a), content_type="application/json")
a = get_molecule_info_status(molecule)
a["job_form"] = job_form
a["mol_form"] = MoleculeForm()
return render(request, "chem/molecule_detail.html", a)
def edit_job(job_id):
job = JobModel.get_by_id(int(job_id))
if not job:
flash(_('no such job'), 'error')
return redirect(url_for('exhibitor.jobs'))
form = JobForm(request.form, obj=job)
if request.method == 'POST' and form.validate():
try:
job.title = form.title.data
job.type = form.type.data
job.enterprise = ndb.key(form.enterprise.data)
job.content = form.content.data
job.put()
flash('job modified successfully!', 'success')
except CapabilityDisabledError:
flash('fail to modify job', 'error')
return render_template('exhibitors/edit_job.html', form=form, job=job)
def new_job():
form = JobForm(request.form)
enterprises = EnterpriseModel.query()
form.enterprises.choices = [(e.key.urlsafe(), e.name) for e in enterprise]
if request.method == 'POST' and form.validate():
user = flask_login.current_user
job = JobModel(title=form.title.data,
type=form.type.data,
enterprise=ndb.Key(form.enterprise.data),
content=form.content.data,
poster=user.key)
try:
job.put()
return redirect(url_for('exhibitor.jobs'))
except CapabilityDisabledError:
return render_template('exhibitors/new_job.html', form=form)
return render_template('exhibitors/new_job.html', form=form)
def edit_job(job_id):
job = JobModel.get_by_id(int(job_id))
if not job:
flash(_('no such job'), 'error')
return redirect(url_for('exhibitor.jobs'))
form = JobForm(request.form, obj=job)
if request.method == 'POST' and form.validate():
try:
job.title = form.title.data
job.type = form.type.data
job.enterprise = ndb.key(form.enterprise.data)
job.content = form.content.data
job.put()
flash('job modified successfully!', 'success')
except CapabilityDisabledError:
flash('fail to modify job', 'error')
return render_template('exhibitors/edit_job.html', form=form, job=job)
def new_job():
form = JobForm(request.form)
enterprises = EnterpriseModel.query()
form.enterprises.choices = [(e.key.urlsafe(), e.name) for e in enterprise]
if request.method == 'POST' and form.validate():
user = flask_login.current_user
job = JobModel(
title = form.title.data,
type = form.type.data,
enterprise = ndb.Key(form.enterprise.data),
content = form.content.data,
poster = user.key
)
try:
job.put()
return redirect(url_for('exhibitor.jobs'))
except CapabilityDisabledError:
return render_template('exhibitors/new_job.html', form=form)
return render_template('exhibitors/new_job.html', form=form)
def new_job():
form = JobForm()
if form.validate_on_submit():
session = db.create_session()
job = models.jobs.Jobs(job=form.job.data,
work_size=form.work_size.data,
start_date=form.start_date.data,
end_date=form.end_date.data,
collaborators=form.collaborators.data,
is_finished=form.is_finished.data,
team_leader=form.team_leader.data,
hazard_category=form.hazard_category.data)
session.add(job)
session.commit()
return redirect('/jobs')
return render_template('new_job.html',
title='New job',
form=form,
current_user=current_user)
def get(self, repo_id):
form = JobForm(request.form)
travispy = g.travispy
repo = travispy.repo(repo_id)
return render_template('job_form.html',
form=form,
repo_id=repo_id,
command='new',
slug=repo.slug)
def edit_job(id):
form = JobForm()
if request.method == "GET":
session = db.create_session()
job = session.query(models.jobs.Jobs).filter(
models.jobs.Jobs.id == id,
((models.jobs.Jobs.user == current_user) |
(models.jobs.Jobs.team_leader == 1))).first()
if job:
form.job.data = job.job
form.work_size.data = job.work_size
form.start_date.data = job.start_date
form.end_date.data = job.end_date
form.collaborators.data = job.collaborators
form.is_finished.data = job.is_finished
form.team_leader.data = job.team_leader
form.hazard_category.data = job.hazard_category
else:
abort(404)
if form.validate_on_submit():
session = db.create_session()
job = session.query(models.jobs.Jobs).filter(
models.jobs.Jobs.id == id,
((models.jobs.Jobs.user == current_user) |
(models.jobs.Jobs.team_leader == 1))).first()
if job:
job.job = form.job.data
job.work_size = form.work_size.data
job.start_date = form.start_date.data
job.end_date = form.end_date.data
job.collaborators = form.collaborators.data
job.is_finished = form.is_finished.data
job.team_leader = form.team_leader.data
job.hazard_category = form.hazard_category.data
session.commit()
return redirect('/jobs')
else:
abort(404)
return render_template('new_job.html',
title='Редактирование новости',
form=form)
def home():
"""Render website's home page."""
form = JobForm()
if form.validate_on_submit():
uniqid = generate_uniqid(10)
jobdir = app.config['UPLOAD_FOLDER'] + "/" + uniqid + "/"
os.makedirs(jobdir)
mp3_filename = secure_filename(form.mp3.data.filename)
mp3_new_name = jobdir + uniqid + ".mp3"
form.mp3.data.save(mp3_new_name)
pic_filename = secure_filename(form.pic.data.filename)
_, pic_extension = os.path.splitext(pic_filename)
pic_new_name = jobdir + uniqid + pic_extension
form.pic.data.save(pic_new_name)
video_output = jobdir + uniqid + ".mkv"
task = tasks.make_video.apply_async(
(uniqid, pic_new_name, mp3_new_name, video_output),
countdown=app.config['PHOSIC_TASK_DELAY'],
expires=app.config['PHOSIC_TASK_MAX_EXECUTION_TIME'])
# Create database item
job = models.Job(
uniqid=uniqid,
task_uuid=task.id,
email=form.email.data,
created=datetime.datetime.utcnow(),
expires=datetime.datetime.utcnow() + datetime.timedelta(
minutes=app.config["PHOSIC_JOB_EXPIRY_MINUTES"]),
mp3_name=mp3_filename[:255],
pic_name=pic_filename[:255],
)
db.session.add(job)
db.session.commit()
return redirect(url_for('jobs', job_id=job.uniqid))
return render_template('home.html', form=form)
def add(request):
current_page = 'jobs'
page_title = u'发布招聘信息'
# 检查用户选择的城市是否存在
if check_city(request.GET.get('city_name', False)):
request.session['job_city'] = request.GET.get('city_name')
else:
return index(request=request)
# 打印表单
if request.method == 'GET':
form = JobForm()
return render('jobs_add.html',
locals(),
context_instance=RequestContext(request))
# 处理提交数据
form = JobForm(request.POST)
if form.is_valid():
data = form.cleaned_data
new_job = Job()
new_job.title = data['title']
new_job.city = request.session.get('job_city', '北京')
new_job.company = data['company']
new_job.website = data['website']
new_job.email = data['email']
new_job.content = data['content']
try:
new_job.save()
except Exception, e:
return HttpResponse('保存招聘信息时出现错误：' + str(e))
else:
msg = '提交成功，正在等待管理员审核...'
# 发送信号
new_job_was_post.send(sender=new_job.__class__, job=new_job)
return render('posted.html',
locals(),
context_instance=RequestContext(request))
def add(request):
current_page = 'jobs'
page_title = u'发布招聘信息'
# 检查用户选择的城市是否存在
if check_city(request.GET.get('city_name',False)):
request.session['job_city'] = request.GET.get('city_name')
else:
return index(request=request)
# 打印表单
if request.method == 'GET':
form = JobForm()
return render('jobs_add.html',locals(),context_instance=RequestContext(request))
# 处理提交数据
form = JobForm(request.POST)
if form.is_valid():
data = form.cleaned_data
new_job = Job()
new_job.title = data['title']
new_job.city = request.session.get('job_city','北京')
new_job.company = data['company']
new_job.website = data['website']
new_job.email = data['email']
new_job.content = data['content']
try:
new_job.save()
except Exception,e:
return HttpResponse('保存招聘信息时出现错误：'+str(e))
else:
msg = '提交成功，正在等待管理员审核...'
# 发送信号
new_job_was_post.send(
sender = new_job.__class__,
job = new_job
)
return render('posted.html',locals(),context_instance=RequestContext(request))
def upload_data(request):
switch = {
"logparse": parse_log,
"longchain": long_chain_limit,
"gjfreset": reset_gjf,
"structureview": view_structure,
}
if request.method == "POST":
upload_form = UploadForm(request.POST or None, files=request.FILES)
if upload_form.is_valid():
return switch[request.POST["options"]](request, upload_form)
else:
upload_form = UploadForm()
c = {
"upload_form": upload_form,
"job_form": JobForm.get_form(request, "{{ name }}", initial=True),
}
return render(request, "chem/upload_log.html", c)
def upload_data(request):
switch = {
"logparse": parse_log,
"longchain": long_chain_limit,
"gjfreset": reset_gjf,
"structureview": view_structure,
"percent": get_percent,
}
if request.method == "POST":
upload_form = UploadForm(request.POST or None, files=request.FILES)
if upload_form.is_valid():
return switch[request.POST["options"]](request, upload_form)
else:
upload_form = UploadForm()
c = {
"upload_form": upload_form,
"job_form": JobForm.get_form(request, "{{ name }}", initial=True),
}
return render(request, "chem/upload_log.html", c)
def multi_job(request):
form = JobForm.get_form(request, "{{ name }}")
c = {
"form": form,
}
if not form.is_valid(request.method):
if request.is_ajax():
job_form_html = render_crispy_form(
form, context=RequestContext(request))
a = {
"success": False,
"job_form_html": job_form_html,
"mol_form_html": '',
}
return HttpResponse(json.dumps(a),
content_type="application/json")
return render(request, "chem/multi_job.html", c)
d = dict(form.cleaned_data)
if request.method == "POST":
cred = d.pop("credential")
files = request.FILES.getlist("files")
strings = [''.join(f.readlines()) for f in files]
names = [os.path.splitext(f.name)[0] for f in files]
a = cluster.interface.run_jobs(cred, names, strings, **d)
do_html = request.REQUEST.get("html", False)
if do_html:
html = render_to_string("chem/multi_submit.html", a)
temp = {"success": True, "html": html}
return HttpResponse(json.dumps(temp),
content_type="application/json")
else:
return HttpResponse(json.dumps(a),
content_type="application/json")
string = request.REQUEST.get('filenames', '').replace('\r\n', ',').replace('\n', ',')
ret_zip = get_multi_job(string, form)
response = HttpResponse(ret_zip, content_type="application/zip")
response["Content-Disposition"] = "attachment; filename=output.zip"
return response
def multi_molecule_zip(request, string):
try:
autoflip = request.REQUEST.get("autoflip")
molecules, warnings, errors, news = get_multi_molecule_status(
string, autoflip=autoflip)
except ValueError as e:
logger.warn(str(e))
c = {
"error": str(e)
}
return render(request, "chem/multi_molecule.html", c)
mol_form = MoleculeForm(request.REQUEST)
mol_form.is_valid()
if request.REQUEST.get("job"):
job_form = JobForm.get_form(request, "{{ name }}")
if not job_form.is_valid():
f = lambda x: 'checked' if request.REQUEST.get(x) else ''
c = {
"pagename": string,
"job_form": job_form,
"mol_form": mol_form,
"gjf": f("gjf"),
"mol2": f("mol2"),
"image": f("image"),
"job": f("job"),
}
return render(request, "chem/multi_molecule.html", c)
else:
job_form = None
selection = ("image", "mol2", "job", "gjf")
options = [x for x in selection if request.REQUEST.get(x)]
if request.REQUEST.get("new", ''):
molecules = [x for i, x in enumerate(molecules) if news[i]]
ret_zip = get_multi_molecule(molecules, options, mol_form, job_form)
response = HttpResponse(ret_zip, content_type="application/zip")
response["Content-Disposition"] = "attachment; filename=molecules.zip"
return response
def multi_job(request):
form = JobForm.get_form(request, "{{ name }}")
c = {
"form": form,
}
if not form.is_valid(request.method):
if request.is_ajax():
job_form_html = render_crispy_form(form,
context=RequestContext(request))
a = {
"success": False,
"job_form_html": job_form_html,
"mol_form_html": '',
}
return HttpResponse(json.dumps(a), content_type="application/json")
return render(request, "chem/multi_job.html", c)
d = dict(form.cleaned_data)
if request.method == "POST":
cred = d.pop("credential")
files = request.FILES.getlist("files")
strings = [''.join(f.readlines()) for f in files]
names = [os.path.splitext(f.name)[0] for f in files]
a = cluster.interface.run_jobs(cred, names, strings, **d)
do_html = request.REQUEST.get("html", False)
if do_html:
html = render_to_string("chem/multi_submit.html", a)
temp = {"success": True, "html": html}
return HttpResponse(json.dumps(temp),
content_type="application/json")
else:
return HttpResponse(json.dumps(a), content_type="application/json")
string = request.REQUEST.get('filenames',
'').replace('\r\n', ',').replace('\n', ',')
ret_zip = get_multi_job(string, form)
response = HttpResponse(ret_zip, content_type="application/zip")
response["Content-Disposition"] = "attachment; filename=output.zip"
return response
def multi_molecule_zip(request, string):
try:
autoflip = request.REQUEST.get("autoflip")
molecules, warnings, errors, news = get_multi_molecule_status(
string, autoflip=autoflip)
except ValueError as e:
logger.warn(str(e))
c = {"error": str(e)}
return render(request, "chem/multi_molecule.html", c)
mol_form = MoleculeForm(request.REQUEST)
mol_form.is_valid()
if request.REQUEST.get("job"):
job_form = JobForm.get_form(request, "{{ name }}")
if not job_form.is_valid():
f = lambda x: 'checked' if request.REQUEST.get(x) else ''
c = {
"pagename": string,
"job_form": job_form,
"mol_form": mol_form,
"gjf": f("gjf"),
"mol2": f("mol2"),
"image": f("image"),
"job": f("job"),
}
return render(request, "chem/multi_molecule.html", c)
else:
job_form = None
selection = ("image", "mol2", "job", "gjf")
options = [x for x in selection if request.REQUEST.get(x)]
if request.REQUEST.get("new", ''):
molecules = [x for i, x in enumerate(molecules) if news[i]]
ret_zip = get_multi_molecule(molecules, options, mol_form, job_form)
response = HttpResponse(ret_zip, content_type="application/zip")
response["Content-Disposition"] = "attachment; filename=molecules.zip"
return response
def create():
form = JobForm()
print(form.validate_on_submit(), '---------------1------------')
if form.validate_on_submit():
company_id = current_user.id
print('职位视图 调用--------')
form.create_job(company_id)
flash('职位创建成功', 'success')
return redirect_job_index()
print(' 职位视图结束-------')
return render_template('job/create.html',
form=form,
active='manage',
panel='create')
def reset_gjf(request, upload_form):
job_form = JobForm.get_form(request, "{{ name }}")
errors = []
strings = []
names = []
for f in upload_form.cleaned_data["files"]:
try:
parser = fileparser.Log(f)
name, _ = os.path.splitext(f.name)
td = False
if request.REQUEST.get("td_reset"):
name += '_TD'
td = True
strings.append(parser.format_gjf(td=td))
names.append(name)
except Exception as e:
logger.warn("There was an error when trying to reset a gjf: '%s'" % str(e))
errors.append((f.name, e))
if request.REQUEST.get("gjf_submit"):
if not job_form.is_valid(request.method):
if request.is_ajax():
upload_form_html = render_crispy_form(upload_form,
context=RequestContext(request))
job_form_html = render_crispy_form(job_form,
context=RequestContext(request))
a = {
"success": False,
"job_form_html": job_form_html,
"upload_form_html": upload_form_html,
}
return HttpResponse(json.dumps(a),
content_type="application/json")
c = {
"job_form": job_form,
"upload_form": upload_form,
}
return render(request, "chem/upload_log.html", c)
d = dict(job_form.cleaned_data)
cred = d.pop("credential")
a = cluster.interface.run_jobs(cred, names, strings, **d)
a["failed"].extend(errors)
do_html = request.REQUEST.get("html", False)
if do_html:
html = render_to_string("chem/multi_submit.html", a)
temp = {"success": True, "html": html}
return HttpResponse(json.dumps(temp),
content_type="application/json")
else:
return HttpResponse(json.dumps(a),
content_type="application/json")
buff = StringIO()
zfile = zipfile.ZipFile(buff, 'w', zipfile.ZIP_DEFLATED)
for name, string in zip(names, strings):
zfile.writestr("%s.gjf" % name, string)
if errors:
temp = ['%s - %s' % (name, error) for (name, error) in errors]
zfile.writestr("errors.txt", '\n'.join(temp))
zfile.close()
buff.flush()
ret_zip = buff.getvalue()
buff.close()
response = HttpResponse(ret_zip, content_type="application/zip")
response["Content-Disposition"] = "attachment; filename=output.zip"
return response
def reset_gjf(request, upload_form):
job_form = JobForm.get_form(request, "{{ name }}")
errors = []
strings = []
names = []
for f in upload_form.cleaned_data["files"]:
try:
parser = fileparser.Log(f)
name, _ = os.path.splitext(f.name)
td = False
if request.REQUEST.get("td_reset"):
name += '_TD'
td = True
strings.append(parser.format_gjf(td=td))
names.append(name)
except Exception as e:
logger.warn("There was an error when trying to reset a gjf: '%s'" %
str(e))
errors.append((f.name, e))
if request.REQUEST.get("gjf_submit"):
if not job_form.is_valid(request.method):
if request.is_ajax():
upload_form_html = render_crispy_form(
upload_form, context=RequestContext(request))
job_form_html = render_crispy_form(
job_form, context=RequestContext(request))
a = {
"success": False,
"job_form_html": job_form_html,
"upload_form_html": upload_form_html,
}
return HttpResponse(json.dumps(a),
content_type="application/json")
c = {
"job_form": job_form,
"upload_form": upload_form,
}
return render(request, "chem/upload_log.html", c)
d = dict(job_form.cleaned_data)
cred = d.pop("credential")
a = cluster.interface.run_jobs(cred, names, strings, **d)
a["failed"].extend(errors)
do_html = request.REQUEST.get("html", False)
if do_html:
html = render_to_string("chem/multi_submit.html", a)
temp = {"success": True, "html": html}
return HttpResponse(json.dumps(temp),
content_type="application/json")
else:
return HttpResponse(json.dumps(a), content_type="application/json")
buff = StringIO()
zfile = zipfile.ZipFile(buff, 'w', zipfile.ZIP_DEFLATED)
for name, string in zip(names, strings):
zfile.writestr("%s.gjf" % name, string)
if errors:
temp = ['%s - %s' % (name, error) for (name, error) in errors]
zfile.writestr("errors.txt", '\n'.join(temp))
zfile.close()
buff.flush()
ret_zip = buff.getvalue()
buff.close()
response = HttpResponse(ret_zip, content_type="application/zip")
response["Content-Disposition"] = "attachment; filename=output.zip"
return response
def add_edit_item(request, model_name, add_edit, edit_id):
"""Add/Edit page for the inventory"""
if add_edit == "add":
edit_id = None
if _checkModel(model_name):
directory = "asset_inventory/add_edit_Pages/"
# Adding or Editing a Job
if model_name == "Job":
templateFile = directory + "Job.html"
post_data = request.POST or None
try:
Job_Instance = Job.objects.get(pk=edit_id)
except Job.DoesNotExist:
Job_Instance = None
if add_edit == "edit":
return HttpResponseRedirect(reverse("asset_inventory_add_edit_item", args=["Job", "add", "new"]))
Job_Form = JobForm(post_data, instance=Job_Instance)
if Job_Form.is_valid():
Job_Occurance = Job_Form.save()
return HttpResponseRedirect(reverse("asset_inventory_list_model", args=["Job"]))
return render_to_response(templateFile, {"form": Job_Form}, context_instance=RequestContext(request))
# Adding or Editing a Location
elif model_name == "Location":
templateFile = directory + "Location.html"
post_data = request.POST or None
try:
Location_Instance = Location.objects.get(pk=edit_id)
except Location.DoesNotExist:
Location_Instance = None
if add_edit == "edit":
return HttpResponseRedirect(
reverse("asset_inventory_add_edit_item", args=["Location", "add", "new"])
)
Location_Form = LocationForm(post_data, instance=Location_Instance)
if Location_Form.is_valid():
Location_Occurance = Location_Form.save()
return HttpResponseRedirect(reverse("asset_inventory_list_model", args=["Location"]))
return render_to_response(templateFile, {"form": Location_Form}, context_instance=RequestContext(request))
# Adding or Editing a Person
elif model_name == "Person":
templateFile = directory + "Person.html"
post_data = request.POST or None
try:
Person_Instance = Person.objects.get(pk=edit_id)
except Person.DoesNotExist:
Person_Instance = None
if add_edit == "edit":
return HttpResponseRedirect(reverse("asset_inventory_add_edit_item", args=["Person", "add", "new"]))
Person_Form = PersonForm(post_data, instance=Person_Instance)
if Person_Form.is_valid():
Person_Occurance = Person_Form.save()
return HttpResponseRedirect(reverse("asset_inventory_list_model", args=["Person"]))
return render_to_response(templateFile, {"form": Person_Form}, context_instance=RequestContext(request))
# Adding or Editing a Purchase
elif model_name == "Purchase":
templateFile = directory + "Purchase.html"
post_data = request.POST or None
try:
Purchase_Instance = Purchase.objects.get(pk=edit_id)
except Purchase.DoesNotExist:
Purchase_Instance = None
if add_edit == "edit":
return HttpResponseRedirect(
reverse("asset_inventory_add_edit_item", args=["Purchase", "add", "new"])
)
Purchase_Form = PurchaseForm(post_data, instance=Purchase_Instance)
if Purchase_Form.is_valid():
Purchase_Occurance = Purchase_Form.save()
return HttpResponseRedirect(reverse("asset_inventory_list_model", args=["Purchase"]))
return render_to_response(templateFile, {"form": Purchase_Form}, context_instance=RequestContext(request))
# Adding or Editing a Status
elif model_name == "Status":
templateFile = directory + "Status.html"
post_data = request.POST or None
try:
Status_Instance = Status.objects.get(pk=edit_id)
except Status.DoesNotExist:
Status_Instance = None
if add_edit == "edit":
return HttpResponseRedirect(reverse("asset_inventory_add_edit_item", args=["Status", "add", "new"]))
Status_Form = StatusForm(post_data, instance=Status_Instance)
if Status_Form.is_valid():
Status_Occurance = Status_Form.save()
return HttpResponseRedirect(reverse("asset_inventory_list_model", args=["Status"]))
return render_to_response(templateFile, {"form": Status_Form}, context_instance=RequestContext(request))
# Adding or Editing a Esign
elif model_name == "Esign":
templateFile = directory + "Esign.html"
post_data = request.POST or None
try:
Esign_Instance = Esign.objects.get(pk=edit_id)
except Esign.DoesNotExist:
Esign_Instance = None
if add_edit == "edit":
return HttpResponseRedirect(reverse("asset_inventory_add_edit_item", args=["Esign", "add", "new"]))
Esign_Form = EsignForm(post_data, instance=Esign_Instance)
if Esign_Form.is_valid():
Esign_Occurance = Esign_Form.save()
return HttpResponseRedirect(reverse("asset_inventory_list_model", args=["Esign"]))
return render_to_response(templateFile, {"form": Esign_Form}, context_instance=RequestContext(request))
# Adding or Editing a Device
elif model_name == "Device":
templateFile = directory + "Device.html"
post_data = request.POST or None
try:
Device_Instance = Device.objects.get(pk=edit_id)
except Device.DoesNotExist:
Device_Instance = None
if add_edit == "edit":
return HttpResponseRedirect(reverse("asset_inventory_add_edit_item", args=["Device", "add", "new"]))
Device_Form = DeviceForm(post_data, instance=Device_Instance)
if Device_Form.is_valid():
Device_Occurance = Device_Form.save()
return HttpResponseRedirect(reverse("asset_inventory_list_model", args=["Device"]))
return render_to_response(templateFile, {"form": Device_Form}, context_instance=RequestContext(request))
# This is a catch all response, if some unforseen error manages
# to occur with the calling of add/edit pages
else:
render_to_response(reverse("homepage"))
def edit_job(keyurl):
key = ndb.Key(urlsafe=keyurl)
job = key.get()
if not job:
flash(_('no such job'), 'error')
return redirect(url_for('admin.jobs'))
form = JobForm(request.form, obj=job)
enterprises = EnterpriseModel.query()
mails = EmailModel.query()
form.enterprise.choices = [(e.key.urlsafe(), e.name) for e in enterprises]
grouped_emails = {e.key.urlsafe(): [] for e in enterprises}
for m in mails:
key = m.enterprise.urlsafe()
if key in grouped_emails:
grouped_emails[key].append({'url': m.key.urlsafe(), 'email': m.email})
form.enterprise_email.choices = [(i['url'], i['email']) for value in grouped_emails.values() for i in value]
if request.method == 'POST' and form.validate():
job.type = form.type.data
job.is_online = form.is_online.data
mails = []
for item in form.enterprise_email.data:
mail = ndb.Key(urlsafe=item)
mails.append(mail)
job.enterprise_email = mails
job.enterprise = ndb.Key(urlsafe=form.enterprise.data)
for lang in ['fr', 'en', 'zh']:
job.meta[lang]['published'] = getattr(form, "publish_"+lang).data
job.meta[lang]['title'] = getattr(form, "title_"+lang).data
job.meta[lang]['content'] = getattr(form, "content_"+lang).data
job.published = job.meta['en']['published'] or job.meta['fr']['published'] or job.meta['zh']['published']
job.default_lang = form.default_lang.data
job.cv_required = form.cv_required.data
try:
job.put()
return redirect(url_for('admin.jobs'))
except CapabilityDisabledError:
flash('error', 'error')
elif request.method == 'GET':
#GET handle goes here
#in case of no enterprise when importing
if job.enterprise:
form.enterprise.data = job.enterprise.urlsafe()
form.enterprise_email.choices = [(i['url'], i['email']) for i in grouped_emails[form.enterprise.data]]
if job.is_online:
form.is_online.data = True
form.apply_url.data = job.apply_url
else:
form.is_online.data = False
urls = []
for e in job.enterprise_email:
urls.append(e.urlsafe())
form.enterprise_email.data = urls
for lang in ['fr', 'en', 'zh']:
v = getattr(form, "publish_"+lang)
v.data = job.meta[lang]['published']
v = getattr(form, "title_"+lang)
v.data = job.meta[lang]['title']
v = getattr(form, "content_"+lang)
v.data = job.meta[lang]['content']
return render_template('admin/edit_job.html', form=form, keyurl=keyurl, grouped_emails= json.dumps(grouped_emails))
def new_job():
"""
create new job infos
"""
form = JobForm(request.form)
enterprises = EnterpriseModel.query()
mails = EmailModel.query()
form.enterprise.choices = [(e.key.urlsafe(), e.name) for e in enterprises]
if len(form.enterprise.choices) == 0:
#no enterprise, create one at first
flash('there is no enterprise, please create one before add new job', 'error')
return redirect(url_for('admin.new_enterprise'))
grouped_emails = {e.key.urlsafe(): [] for e in enterprises}
for m in mails:
key = m.enterprise.urlsafe()
if key in grouped_emails:
grouped_emails[key].append({'url': m.key.urlsafe(), 'email': m.email})
form.enterprise_email.choices = [(i['url'], i['email']) for value in grouped_emails.values() for i in value]
if request.method == 'POST' and form.validate():
user = flask_login.current_user
enterprise = ndb.Key(urlsafe=form.enterprise.data)
mails = []
for item in form.enterprise_email.data:
mail = ndb.Key(urlsafe=item)
mails.append(mail)
fr = {
'published': form.publish_fr.data,
'title': form.title_fr.data,
'content': form.content_fr.data
}
en = {
'published': form.publish_en.data,
'title': form.title_en.data,
'content': form.content_en.data
}
zh = {
'published': form.publish_zh.data,
'title': form.title_zh.data,
'content': form.content_zh.data
}
meta = {
"en": en,
"fr": fr,
"zh": zh
}
job = JobModel(
type=form.type.data,
is_online=form.is_online.data,
enterprise=enterprise,
enterprise_email=mails,
meta=meta,
published=fr["published"] or en["published"] or zh["published"],
default_lang=form.default_lang.data,
cv_required=form.cv_required.data,
# poster = user.key
)
try:
job.put()
return redirect(url_for('admin.jobs'))
except CapabilityDisabledError:
flash('add job error!', 'error')
return render_template('admin/new_job.html', form=form, grouped_emails = json.dumps(grouped_emails))
