def job_upload(request):
if request.method == 'POST':
# script= request.POST.get('script')
# print type(script)
print request
myFile = request.FILES.get('script', None)
name = request.POST.get('name')
describe = request.POST.get('describe')
print name, describe
if name:
save_name = name
else:
save_name = myFile
# print(myFile._size) # 文件大小字节数
if Job.objects.filter(job_name=myFile).exists():
return render_to_response('400.html', {'info': '脚本已经存在'})
data = myFile.read()
job_obj = Job()
job_obj.job_name = save_name
job_obj.info = data
job_obj.describe = describe
job_obj.save()
return render_to_response('job_upload.html',
{'username': request.user.username})
else:
return render_to_response('job_upload.html',
{'username': request.user.username})
def run_job(credential, gjfstring, jobstring=None, **kwargs):
results = {
"jobid": None,
"error": None,
}
try:
results["cluster"] = credential.cluster.name
if not credential.user.is_staff:
results["error"] = "You must be a staff user to submit a job."
return results
ssh = get_ssh_connection_obj(credential)
sftp = get_sftp_connection_obj(credential)
except:
results["error"] = "Invalid credential"
results["cluster"] = None
logger.info("Invalid credential %s" % credential)
return results
with ssh, sftp:
jobid, error = _run_job(ssh, sftp, gjfstring, jobstring, **kwargs)
results["jobid"] = jobid
results["error"] = error
if not error:
job = Job(credential=credential, jobid=jobid, **kwargs)
job.save()
return results
def testScore():
job = Job(1, 1, 1, 4, 4, 1000, 100, 200, 1, 1, datetime.datetime.now(),
datetime.datetime.now())
truck = Truck(1, 1, 1, 5, 5, fk_truck_type_id=3, fk_transporter_id=1)
result = math.sqrt(32) + math.sqrt(18) + 1000 + (1000 / math.sqrt(18))
score = calculations.calculate_score(truck, job)
assert score == result
def create_job(jwt):
request_value = request.get_json()
if request_value is None:
abort(400)
company_id = request_value['company_id']
company = Company.query.filter_by(id=company_id).one_or_none()
if company is None:
abort(400)
job = Job(
request_value['title'],
request_value['description'],
request_value['city'],
request_value['state'],
request_value['imageBase64'],
request_value['is_active'],
request_value['is_remote'],
company_id
)
job.insert()
return jsonify({
'status_code': 200,
'job': job.format_long(),
'message': 'The job was successfully created',
'success': True,
})
def get_contents(soup):
# 获取job info
results = soup.select('.con_list_item')
for result in results:
content = result.attrs
experience, education = result.select('.li_b_l')[0].get_text().replace(
' ', '').strip().split('/')
tag = result.select('.li_b_l')[1].get_text()
positionname = content.get('data-positionname')
positionid = content.get('data-positionid')
companyid = content.get('data-positionid')
salary = content.get('data-salary')
s_salary, e_salary = split_salary(salary)
company = content.get('data-company')
area = result.select('.add')[0].find('em').get_text()
job = Job(positionname=positionname,
positionid=positionid,
companyid=companyid,
s_salary=s_salary,
e_salary=e_salary,
company=company,
status=0,
area=area,
experience=experience,
education=education,
tag=tag)
session.add(job)
message = "{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}".format(
positionname, positionid, companyid, s_salary, e_salary, company,
area, experience, education, tag)
logger.info(message)
session.commit()
def test_job_to_dict(self):
job = Job(
job_id=1,
job_title="name",
education="Bachelor",
description="a job",
salary=1.0,
city1="city1",
city2="city2",
city3="city3",
city4="city4",
city5="city5",
salary1=1.0,
salary2=1.0,
salary3=1.0,
salary4=1.0,
salary5=1.0,
)
job_stats_test = {
"id": 1,
"job title": "name",
"annual salary": 1.0,
"education": "Bachelor",
"top cities": ["city1", "city2", "city3", "city4", "city5"],
"top cities salaries": {
"city1": 1.0,
"city2": 1.0,
"city3": 1.0,
"city4": 1.0,
"city5": 1.0,
},
"description": "a job",
}
self.assertEqual(job_stats_test, job.toDict())
def add_job_view(request):
if request.method == 'POST':
title = request.POST.get('job-title')
date = request.POST.get('job-date')
description = request.POST.get('job-description')
user = User.objects.get(username=request.user.username)
new_job = Job(user=user,
title=title,
description=description,
created=datetime.strptime(date, '%Y-%m-%d'))
new_job.save()
icon = '<i class="fa fa-plus text-success" aria-hidden="true"></i>'
added_msg = "Added new job <strong>{0}</strong>".format(title)
new_activity = Activity(
user=User.objects.get(username=request.user.username),
icon=icon,
description=added_msg)
new_activity.save()
messages.success(request, added_msg, extra_tags='added_job')
return redirect('dashboard:index')
def insert_new_job(job_id, async_id, filename=None, client_ip=None):
job = Job(job_id=str(job_id),
async_id=str(async_id),
filename=filename,
client_ip=client_ip)
db_session.add(job)
db_session.commit()
def submit_job(user_id):
user = User.query.get_or_404(user_id)
form = AddJobForm()
if form.validate_on_submit():
job_title = form.job_title.data
location = form.location.data
start_year = form.start_year.data
day_rate = form.day_rate.data
cont_company = form.cont_company.data
user_id = f"{user.id}"
job = Job(job_title=job_title,
location=location,
start_year=start_year,
day_rate=day_rate,
cont_company=cont_company,
user_id=user_id)
db.session.add(job)
db.session.commit()
return redirect(f"/user/{user.id}")
return render_template('add_job.html', form=form)
def upload_file_to_s3(file, user_id, data):
from models import Job, PossibleJobStates
aws_keys = get_aws_keys()
session = boto3.Session(aws_access_key_id=aws_keys[0],
aws_secret_access_key=aws_keys[1])
s3 = session.resource('s3')
bucket = s3.Bucket(BUCKET_NAME)
# This filename is done for debugging purposes, but also to ensure uniqueness on S3
current_time = datetime.datetime.now()
user_id = str(user_id)
file_name = "{}_{}_{}_{}_{}".format(file.filename.replace(" ", "_"),
user_id, data['input_vendor'],
data['output_vendor'],
str(current_time).replace(" ", "-"))
s3_key = FOLDER_NAME + file_name
try:
bucket.put_object(Key=s3_key, Body=file)
except:
raise Generic('Error: Could not upload file')
file_location = BUCKET_URL + s3_key
job_state = Job(user_id=user_id,
input_vendor=data['input_vendor'],
output_vendor=data['output_vendor'],
timestamp=current_time,
file_url=file_location,
state=PossibleJobStates.STARTED)
return job_state
def populate_jobs():
with open("static/json/jobs.json") as inp:
jobs = json.load(inp)
for job_name in jobs:
j = jobs[job_name]
job = Job(
job_id=j["id"],
job_title=j["title"],
description=j["description"],
education=j["education"],
salary=j["national-salary"],
city1=j["top-cities"][0],
city2=j["top-cities"][1],
city3=j["top-cities"][2],
city4=j["top-cities"][3],
city5=j["top-cities"][4],
salary1=j["top-cities-salaries"][j["top-cities"][0]],
salary2=j["top-cities-salaries"][j["top-cities"][1]],
salary3=j["top-cities-salaries"][j["top-cities"][2]],
salary4=j["top-cities-salaries"][j["top-cities"][3]],
salary5=j["top-cities-salaries"][j["top-cities"][4]],
)
db.session.add(job)
db.session.commit()
print(" Populated jobs")
def new_job(image_id):
image = Image.query.get(image_id)
if not image:
abort(404)
try:
parameters = {}
for key in ["model_name", "maxwidth", "iter_n", "octave_n", "end"]:
parameters[key] = request.form[key]
for num_key in ["maxwidth", "iter_n", "octave_n"]:
parameters[num_key] = int(parameters[num_key])
parameters["model_name"] = str(parameters["model_name"])
except (KeyError, ValueError, TypeError):
abort(400)
if parameters["model_name"] not in list_models().keys():
abort(400)
job = Job(source_image_id=image_id, parameters=json.dumps(parameters))
db.session.add(job)
db.session.commit()
compute_queue.enqueue_call(func='worker.process_job',
timeout=3600,
kwargs={"job_id": job.id})
return redirect(url_for('view', image_id=image.id))
def post(self):
json = request.json
abort_if_invalid_request_params(json, [
'code', 'name', 'description', 'job_category', 'recruiter',
'organization', 'position'
])
job = Job()
job.code = json['code']
job.name = json['name']
job.description = json['description']
job.job_category = json['job_category']
job.recruiter = json['recruiter']
job.organization = json['organization']
job.position = json['position']
if 'salary_min' in json:
job.salary_min = json['salary_min']
if 'salary_max' in json:
job.salary_max = json['salary_max']
if 'currency' in json:
job.currency = json['currency']
job.save()
return me_obj_to_serializable(job)
def create_job():
email = request.json.get('email')
password = request.json.get('password')
user = User.query.filter_by(email=email).first()
if user == None:
return "Incorrect email"
if bcrypt.check_password_hash(user.password, password):
if user.customer:
customer_id = request.json.get('customer_id')
customer_query = Customer.query.get(customer_id)
performer_id = request.json.get('performer_id')
performer_query = Performer.query.get(performer_id)
title = request.json.get('title')
start_time = request.json.get('start_time')
start_time = datetime.strptime(start_time, '%Y-%m-%d,%H:%M')
end_time = request.json.get('end_time')
end_time = datetime.strptime(end_time, '%Y-%m-%d,%H:%M')
address = request.json.get('address')
price_per_hour = request.json.get('price_per_hour')
addedjob = Job(customer=customer_query, performer=performer_query,
title=title, end_time=end_time,start_time=start_time, address=address, price_per_hour=price_per_hour)
db.session.add(addedjob)
db.session.commit()
job_schema = JobSchema()
output = job_schema.dump(addedjob).data
return jsonify(output)
def job_factory():
job = Job(name='Test job',
prefix='/test-job',
created_at=datetime.datetime(2019, 2, 1))
db.session.add(job)
db.session.commit()
return job
def post(self):
flyer = Flyer()
pdf = self.request.get("flyer")
flyer.flyer = db.Blob(pdf)
flyer.name = self.request.get("name")
flyer.put()
flyer.id = str(flyer.key().id())
flyer.put()
recipients = self.request.get("content")
lines = [
r.split(" ") for r in recipients.strip(" \t").split("\n")
if len(r) > 0
]
for line in lines:
email = line[0]
msg = " ".join(line[1:])
job = Job(flyer_id=flyer.id,
email=email,
msg=msg,
count=5,
state="init",
flyer=flyer)
job.put()
self.response.out.write(template.render("templates/finish.html", {}))
def schedule(function,
args=None,
kwargs=None,
priority=5,
run_after=None,
group=None,
meta=None):
"""Schedule a tast for execution.
"""
# Too many arguments
# pylint: disable=R0913
if group:
if type(group) == Group:
expected_group = group
else:
expected_group = Group.latest_group_by_reference(group)
else:
expected_group = None
job = Job(name=full_name(function),
args=dumps(args or []),
kwargs=dumps(kwargs or {}),
meta=dumps(meta or {}),
scheduled=run_after,
priority=priority,
group=expected_group)
job.save()
return job
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 test_unicode_generated(self):
"""Make sure that the unicode generated by a real scheduled job
and one used to create an identity match.
"""
job1 = schedule('async.tests.test_deschedule._example')
job2 = Job(name='async.tests.test_deschedule._example',
args="[]", kwargs="{}")
self.assertEqual(job1.identity, sha1(unicode(job2)).hexdigest())
def deschedule(function, args=None, kwargs=None):
"""Remove any instances of the job from the queue.
"""
job = Job(name=full_name(function),
args=dumps(args or []),
kwargs=dumps(kwargs or {}))
mark_executed = Job.objects.filter(executed=None,
identity=sha1(unicode(job)).hexdigest())
mark_executed.update(executed=datetime.now())
def schedule(function, args=None, kwargs=None, run_after=None, meta=None):
"""Schedule a tast for execution.
"""
job = Job(name=full_name(function),
args=dumps(args or []),
kwargs=dumps(kwargs or {}),
meta=dumps(meta or {}),
scheduled=run_after)
job.save()
return job
def create(name, url):
'''新增'''
job = Job()
job.name = name
job.url = url
job.create_time = datetime.now()
session = Session()
session.add(job)
session.commit()
session.close()
def add(self, title, description, salary, location, remote, internship):
from models import Job
from devjobs import db
try:
j = Job(title, description, salary, location, remote, internship,
self.company)
db.session.add(j)
db.session.commit()
return True
except Exception as e:
return False
def admin_jobs():
splash = ''
if session.get('admin') == True:
if request.method == 'POST':
n = Job(request.form.get('title'), request.form.get('desc'),
request.form.get('exp'))
db_session.add(n)
db_session.commit()
splash = 'Job Created'
return render_template('admin_jobs.html', SPLASH=splash)
return redirect("/login?next=/admin_jobs")
def submit(self, request):
job = Job(query=json.dumps(self.cleaned_data['query']))
try:
job.save()
except DatabaseError:
raise DatabaseIntegrityError()
if self.cleaned_data['query']['type'] == 'FASTA':
pass
else:
pass
def run(clusters, jobs_loads, front_ends, updating_weights_technique,
avg_job_duration, weightes_update_interval, cost_function_weights):
for tik, load in enumerate(jobs_loads):
start_time = time.time()
if tik % weightes_update_interval == 0:
update_clusters_weights(clusters, updating_weights_technique, tik,
cost_function_weights)
for cluster in clusters:
for front_end in front_ends:
job = Job(None, cluster.zone, avg_job_duration, load,
front_end)
cluster.consume(job, tik * 1000)
def getJobInfo(dom, company):
'''获取一个职位的招聘信息'''
job_info = {}
type_tr = dom('.jobInfoItems tr:eq(0)')
trtext = type_tr.text()
trtext = trtext.split(u'：') if trtext else []
if len(trtext) == 2:
k, v = trtext
v = v.replace('/', ',')
job_info[k] = v
trs = dom('.jobInfoItems tr:gt(1)')
for tr in trs:
tr = pq(tr)
tds = tr('td')
for td in tds:
td = pq(td)
tdtext = td.text().split(u'：')
if len(tdtext) == 2:
k, v = tdtext
job_info[k] = v
salary = job_info.get(u'职位月薪')
if salary:
sh = re.search(r'(\d+)-(\d+)', salary)
salary = sh.groups() if sh else (None, None)
else:
salary = (None, None)
quantity = job_info.get(u'招聘人数')
if quantity:
sh = re.search(r'(\d+)', quantity)
quantity = sh.group(0) if sh else None
job = Job()
occ_type = job_info.get(u'职位类别')
occ = Occupational.query.filter(Occupational.type == occ_type).first()
if not occ:
occ = Occupational()
occ.name = 'FILL'
occ.type = occ_type
db.session.add(occ)
job.occupational = occ
job.type = job_info.get(u'工作性质')
job.exp = job_info.get(u'工作经验')
job.manage_exp = job_info.get(u'管理经验')
job.quantity = quantity
job.degree = job_info.get(u'最低学历')
job.salary_low, job.salary_high = salary
job.description = dom('.jobDes').html()
job.etag = ''
return job
def add_job():
form = JobForm(request.form)
if form.validate_on_submit():
new_job = Job(form.title.data, form.database.data, form.host.data,
form.username.data, form.password.data,
form.spreadsheet.data, form.sheet.data, form.query.data,
form.schedule.data)
db_session.add(new_job)
db_session.commit()
return redirect(url_for('home'))
else:
print form.errors
return render_template('pages/job.html', form=form)
def iter_jobs_msg():
with open(
os.path.join(os.path.dirname(__file__), '..', 'datas',
'jobsmsg.json')) as ff:
jobs = json.load(ff)
for job in jobs:
yield Job(name=job['name'],
degree_requirement=job['degree_requirement'],
experience_requirement=job['experience_requirement'],
salary=job['salary'],
address=job['address'],
tags=job['tags'],
company=User.query.filter_by(name=job['company']).first())
def test_job_model(self):
"""Does basic model work?"""
j= Job(job_title="PSO", location="Alaska", start_year="2012", day_rate="210", cont_company="RPS", user_id="94566")
db.session.add(j)
db.session.commit()
# User should have one jobs
self.assertEqual(len(self.u.jobs), 1)
self.assertEqual(self.u.jobs[0].location, 'Alaska')
self.assertEqual(self.u.jobs[0].start_year, 2012)
self.assertEqual(self.u.jobs[0].day_rate, 210)
