def test_list_applications(self):
for i in range(3):
self.setup_dummy_application()
with self.app.app_context():
application = Application(data=self.application_data,
status='deleted')
db.session.add(application)
db.session.flush()
db.session.commit()
application = Application(data=self.application_data,
status='saved')
db.session.add(application)
db.session.flush()
db.session.commit()
res = self.list_applications()
data = json.loads(res.get_data(as_text=True))
assert res.status_code == 200
assert len(data['applications']) == 4
assert 'self' in data['links']
res = self.list_applications_by_status(status='saved')
data = json.loads(res.get_data(as_text=True))
assert res.status_code == 200
assert len(data['applications']) == 1
assert 'self' in data['links']
def seed_applications():
app1 = Application(order_id=1, node_id=1)
app2 = Application(order_id=2, node_id=6)
app3 = Application(order_id=3, node_id=1)
app4 = Application(order_id=4, node_id=1, status="Accepted")
app5 = Application(order_id=5, node_id=6, status="Accepted")
app6 = Application(order_id=6, node_id=1, status="Confirmed")
app7 = Application(order_id=7, node_id=1, status="Confirmed")
app8 = Application(order_id=8, node_id=6, status="Confirmed")
app9 = Application(order_id=11, node_id=1, status="Confirmed")
app10 = Application(order_id=7, node_id=6)
db.session.add(app1)
db.session.add(app2)
db.session.add(app3)
db.session.add(app4)
db.session.add(app5)
db.session.add(app6)
db.session.add(app7)
db.session.add(app8)
db.session.add(app9)
db.session.add(app10)
db.session.commit()
def make_application(request, jobid):
#This function constructs an application from the CV data and the question answers
userid = request.session['id']
user = AppUser.objects.get(pk=userid)
cv = CV.objects.get(owner=userid).cvData
dictCv = json.loads(cv)
dictCv['Answer Percentage'] = request.session['success']
job = Job.objects.get(pk=jobid)
model = MLModel.objects.get(model_name=job.industry_type)
model_cvs = MLcv.objects.filter(model=model)
if len(model_cvs) > 100: # Don't predict until MLModel dataset is > 20 cvs
private_classification = predict(job.industry_type.model_name, dictCv)
print("This is the classification", private_classification)
else:
private_classification = "not_set"
application = Application(user=user,
job=job,
status='Applied',
classification=private_classification,
answer_percent=request.session['success'])
application.save()
request.session['success'] = None
return True
def view_project(project_name):
project = Project.find_by_name(project_name)
if project is None:
return abort(404)
project.description = str(project.description)
project.categories = [c['category_name'] for c in project.categories]
project.requirements = [r['requirement'] for r in project.requirements]
has_prev_application = Application.find(
project_name=project_name,
student_name=current_user.username,
) is not None
if request.method == 'POST':
if has_prev_application:
flash('You can only apply once to each project', 'danger')
else:
if project.check_user(current_user) is False:
flash('You do not fulfill the requirements', 'warning')
else:
application = Application(project_name=project_name,
student_name=current_user.username,
application_date=datetime.now(),
status='pending',
is_new_application=True)
application.save()
flash('Application successfully submitted!', 'success')
try:
temp = render_template('view_project.html',
project=project,
has_prev_application=has_prev_application)
except:
project.description = ''
temp = render_template('view_project.html',
project=project,
has_prev_application=has_prev_application)
return temp
def create_application():
application_json = get_application_json()
json_payload = get_json_from_request()
application = Application()
application.update_from_json(application_json)
save_application(application)
name = json_payload.get('name')
updated_by = json_payload.get('updated_by')
db.session.add(AuditEvent(
audit_type=AuditTypes.create_application,
user=updated_by,
data={},
db_object=application
))
db.session.commit()
publish_tasks.application.delay(
publish_tasks.compress_application(application),
'created',
name=name,
email_address=updated_by,
from_expired=True
)
return jsonify(application=application.serializable), 201
def create_application():
application_json = get_application_json()
json_payload = get_json_from_request()
application = Application()
application.update_from_json(application_json)
save_application(application)
name = json_payload.get('name')
updated_by = json_payload.get('updated_by')
db.session.add(AuditEvent(
audit_type=AuditTypes.create_application,
user=updated_by,
data={},
db_object=application
))
db.session.commit()
publish_tasks.application.delay(
publish_tasks.compress_application(application),
'created',
name=name,
email_address=updated_by,
from_expired=True
)
return jsonify(application=application.serializable), 201
def applications(self, app):
with app.app_context():
db.session.add(Application(id=1, data={}, status='submitted'))
db.session.add(Application(id=2, data={}, status='saved'))
db.session.add(Application(id=3, data={}, status='approved'))
db.session.add(Application(id=4, data={}, status='submitted'))
db.session.commit()
yield db.session.query(Application).all()
def test_for_no_errors_with_empty_product():
assert len(ApplicationValidator(
Application(
data={
'products': {}
})).validate_products()) == 0
assert len(ApplicationValidator(
Application(data={})).validate_products()) == 0
def applications(current_user):
if request.method == 'GET':
applications = Application.where(user_id=current_user._id)
return ApplicationSerializer(applications).serialize()
else:
params = request.get_json()
application = Application.create(name=params['name'],
_id=Application.count() + 1,
secret=uuid.uuid4().hex,
user_id=current_user._id,
created_at=datetime.datetime.now())
return ApplicationSerializer(application).serialize()
def setup_dummy_application(self, mj, data=None):
if data is None:
data = self.application_data
with self.app.app_context():
application = Application(data=data, )
db.session.add(application)
db.session.flush()
application.submit_for_approval()
db.session.commit()
return application.id
def sample_submitted_application(app, request):
with mock.patch('app.models.get_marketplace_jira'):
with app.app_context():
application = Application(
data=request.param,
)
db.session.add(application)
db.session.flush()
application.submit_for_approval()
db.session.commit()
yield application
def setup_dummy_application(self, mj, data=None):
if data is None:
data = self.application_data
with self.app.app_context():
application = Application(
data=data,
)
db.session.add(application)
db.session.flush()
application.submit_for_approval()
db.session.commit()
return application.id
def test_create_approval_task(self, MarketplaceJIRA, JIRA, get_api, get_api_oauth):
with self.app.app_context() as a:
j = JIRA()
get_api_oauth.return_value = j
mj = get_marketplace_jira()
application = Application(
id=99,
status='saved',
data={'name': 'Umbrella Corporation'}
)
domains = db.session.query(Domain).all()
application.submit_for_approval()
mj.create_application_approval_task.assert_called_with(application, domains, None)
def test_create_approval_task(self, MarketplaceJIRA, JIRA, get_api,
get_api_oauth):
with self.app.app_context() as a:
j = JIRA()
get_api_oauth.return_value = j
mj = get_marketplace_jira()
application = Application(id=99,
status='saved',
data={'name': 'Umbrella Corporation'})
domains = db.session.query(Domain).all()
application.submit_for_approval()
mj.create_application_approval_task.assert_called_with(
application, domains, None)
def create_application():
"""Create a new Application"""
name = request.json['name']
identifier = str(uuid.uuid4().hex)
developer = request.json['developer']
type = ApplicationType.query.filter_by(id=request.json['type']).first()
description = request.json['description']
genre = Genre.query.filter_by(id=request.json['genre']).first()
# validate application type
if not type:
return {'status': 'error', 'message': 'Invalid Application Type'}, 400
# validate genre
if not genre:
return {'status': 'error', 'message': 'Invalid Genre Type'}, 400
new_application = Application(name=name, identifier=identifier,
developer=developer, type=type, description=description, genre=genre)
db.session.add(new_application)
db.session.commit()
result = application_schema.dump(new_application).data
return jsonify({'status': 'success', 'message': 'Created new application {}.'.format(name), 'data': result}), 201
def connect(username):
if username == current_user.username:
abort(404)
profile = User.query.filter_by(username=username).first_or_404()
if current_user.is_connected_to(profile) or current_user.submitted_applications.filter_by(recipient=profile).first():
return redirect(url_for("profile", username=username))
if request.method == 'POST':
print("POST")
title = request.form.get("title")
content = request.form.get("content")
if not title or not content:
print("All fields required")
return json.dumps({'status': 'All fields required'})
application = Application(title=title, content=content, sender=current_user, recipient=profile)
db.session.add(application)
db.session.commit()
return json.dumps({'status': 'Successfully sent'})
return render_template('connect.html', profile=profile)
def create_application(country_id, university, major, degree, term, result,
applicant_id, is_transfer):
# TODO: add the authentication of power.
# TODO: verify the repeation of datas.
application = Application(country_id=country_id,
university=university,
major=major,
degree=degree,
term=term,
result=result,
applicant_id=applicant_id)
# new_tags = [Tag.query.filter_by(name="渣三维").first(), Tag.query.filter_by(name="转专业").first()];
# application.tags.extend(new_tags)
# Auto Tag
applicant = Applicant.query.filter_by(id=applicant_id).first()
# FIXME : if language_type is not toefl.
toefl = None
ielts = None
if applicant.language_type == "TOEFL":
toefl = applicant.language_reading + applicant.language_listening + applicant.language_speaking + applicant.language_writing
else:
ielts = (applicant.language_reading + applicant.language_listening +
applicant.language_speaking + applicant.language_writing) / 4
gre = applicant.gre_quantitative + applicant.gre_verbal
gpa = applicant.gpa
new_tags = auto_tags(gre, gpa, is_transfer, toefl, ielts)
application.tags.extend(new_tags)
db.session.add(application)
db.session.commit()
return {'id': application.id}
def get(self, request, version=1, user=None, *args, **kwargs):
serializer = serializers.RequestUserAuth(data=request.query_params)
if serializer.is_valid():
application = Application.find_application(
serializer.validated_data['application_id'])
if application:
return redirect(
get_server(application.url, application.application_id,
application.secret_token).authorize(
redirect_uri='%s?application_id=%s' %
(request.build_absolute_uri(
reverse("user_auth_done")),
application.application_id),
state=request.build_absolute_uri(
reverse("user_auth")),
scope=[
'read_user', 'api', 'profile', 'openid',
'read_repository'
]))
else:
return Response({"message": "Application not found."},
status=status.HTTP_400_BAD_REQUEST)
else:
return Response({"message": serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
def apply():
try:
applicant = Applicant.query.filter_by(aid = request.json['aid']).first()
if applicant is not None:
application = Application.query.filter_by(email = applicant.email).first()
if application is None:
program = Program.query.filter_by(program = request.json['program']).first()
application = Application(
email = applicant.email,
university = 'GSU',
dname = request.json['dname'],
program = program.program,
dateOfApp = datetime.utcnow(),
termOfAdmission = request.json['termOfAdmission'],
yearOfAdmission = request.json['yearOfAdmission'],
admissionStatus = 'PENDING',
dataSentToPaws = 'NO',
applicant_email = applicant.email,
applicant_program = program.program
)
db.session.add(application)
db.session.commit()
return jsonify({'status': status.HTTP_201_CREATED,'message':'Your application sent successfully'})
else:
return jsonify({'status': status.HTTP_200_OK,'message':'Looks like you have already applied.'})
else:
return jsonify({'status':status.HTTP_404_NOT_FOUND,'message':'Applicant not found'})
except Exception as e:
return jsonify({'status':status.HTTP_500_INTERNAL_SERVER_ERROR,'message':str(e)})
def application(student_num, component_id):
if request.method == 'POST':
quantity = request.form['quantity']
# 申请的元器件
component = Component.query.filter_by(id=component_id).first()
# 申请的数量
if quantity == "":
flash("申请数量不能为空")
else:
quantity = int(quantity)
if quantity <= 0:
flash("申请数量有误")
return redirect(url_for("component"))
if quantity > component.quantity:
flash("库存不足")
return redirect(url_for("component"))
# 申请的时间
time = datetime.datetime.now()
time = datetime.datetime.strftime(time, '%Y-%m-%d %H:%M:%S')
application = Application(student_id=student_num,
component_id=component_id,
quantity=quantity,
time=time)
db.session.add(application)
db.session.commit()
component.quantity -= quantity
db.session.add(component)
db.session.commit()
flash("申请中,请注意查看是否申请成功")
return redirect(url_for('component'))
def test_can_get_error_when_no_documents():
application = Application(
data={}
)
errors = ApplicationValidator(application).validate_documents()
assert len(errors) == 1
def application():
form = ApplicationForm()
app = None
if form.validate_on_submit():
apply = Application(accept="Pending",
company=form.company_name.data,
founder=form.founder_names.data,
email=current_user.email,
industry=form.industry.data,
skills=form.team_skills.data,
help_req=form.help_needed.data,
interest=form.interest.data,
gain=form.gain.data,
stage=form.stage.data,
relation=form.relation.data,
web=form.website.data,
links=form.business_docs.data)
db.session.add(apply)
db.session.commit()
flash('Congratulations, you applied successfully!')
return redirect(url_for('index'))
elif request.method == 'GET':
info = Mentee.query.filter_by(email=current_user.email).first()
form.company_name.data = info.company
app = Application.query.filter_by(email=current_user.email).first()
return render_template('application.html', title='Cohort Application Form',
form=form, app=app)
def send_application():
res = {
"state": "success",
"msg": "send applicaton successfully",
"data": []
}
request_data = request.get_json()
driver_id = session.get("id")
good_id = request_data.get("good_id")
if driver_id == None or good_id == None:
res["state"] = "error"
res["msg"] = "f**k you!"
return jsonify(res)
application = Application(driver_id=driver_id, good_id=good_id)
try:
db.session.add(application)
db.session.commit()
except Exception as e:
data["state"] = "error"
data["msg"] = str(e)
return jsonify(res)
def create_application():
form = ApplicationForm()
form['csrf_token'].data = request.cookies['csrf_token']
if form.validate_on_submit():
new_application = Application(sent_out=form.data["sent_out"],
response=form.data["response"],
response_date=form.data["response_date"],
interview=form.data["interview"],
company_id=form.data["company_id"],
user_id=form.data["user_id"],
interview_id=form.data["interview_id"])
db.session.add(new_application)
db.session.commit()
application_info = []
application_info.append({
'sent_out': new_application.sent_out,
'response': new_application.response,
'response_date': new_application.response_date,
'interview': new_application.interview,
'company_id': new_application.company_id,
'user_id': new_application.user_id,
'interview_id': new_application.interview_id
})
application = {
'application': [new_application.id, application_info[0]]
}
return application
return {"message": "Access denied"}, 400
def create_application(email_address=None, name=None):
application = Application(status='saved',
data={
'framework': 'digital-marketplace',
'email': email_address
})
db.session.add(application)
db.session.flush()
audit = AuditEvent(audit_type=AuditTypes.create_application,
user='',
data={},
db_object=application)
db.session.add(audit)
db.session.commit()
publish_tasks.application.delay(
publish_tasks.compress_application(application),
'created',
name=name,
email_address=email_address,
from_expired=False)
return application
def test_deferred_candidates_are_not_counted(self, test_session,
candidates_promoter):
"""
Two candidates apply to the 2019 intake and are successful. One defers to 2019. Both are promoted in the
following year. How many "successes" should be counted for the programme? The answer should be one, because only
one is actually on the programme at the time
"""
test_session.add(Ethnicity(id=4, value="Prefer not to say"))
test_session.commit()
candidates = [Candidate(ethnicity_id=4) for i in range(2)]
# all candidates apply for the 2019 intake and are successful
for candidate in candidates:
candidate.applications.append(
Application(
scheme_id=1,
application_date=date(2018, 6, 1),
scheme_start_date=date(2019, 3, 1),
successful=True,
))
# all candidates are substantively promoted
candidates_promoter(candidates, 1, temporary=False)
# one candidate defers to the 2020 intake
candidates[0].applications[0].defer(date_to_defer_to=date(2020, 3, 1))
# save to the database
test_session.add_all(candidates)
test_session.commit()
data = CharacteristicPromotionReport("FLS", "2019",
"ethnicity").get_data()
expected_output = ["Prefer not to say", 1, 1.0, 0, 0.0, 1]
assert data[0] == expected_output
def applications(app, request):
with app.app_context():
for i in range(1, 6):
db.session.add(Application(id=(i), data={'abn': '123456'}))
db.session.flush()
db.session.commit()
yield Application.query.all()
def test_can_get_errors_as_recruiter_with_no_recruiter_info(recruiter):
assert len(
ApplicationValidator(
Application(data={
'recruiter': recruiter,
'services': {
'service_1': True
}
})).validate_candidates()) == 1
def test_for_no_errors_as_non_recruiter_with_no_recruiter_info():
assert len(
ApplicationValidator(
Application(data={
'recruiter': 'no',
'services': {
'service_1': True
}
})).validate_candidates()) == 0
def test_can_get_errors_with_unfilled_product():
assert len(ApplicationValidator(
Application(
data={
'products': {
'0': {}
}
}
)).validate_products()) == 5
def test_for_no_errors_as_recruiter_with_no_pricing():
assert len(ApplicationValidator(
Application(
data={
'recruiter': 'yes',
'services': {
'service_1': True
}
})).validate_pricing()) == 0
def test_can_get_errors_with_empty_string():
application = Application(
data={
'number_of_employees': ''
}
)
errors = ApplicationValidator(application).validate_details()
assert len(errors) == 1
def create_application():
"""
Creates an application.
"""
form = ApplicationForm()
print(request.get_json())
# Get the csrf_token from the request cookie and put it into the
# form manually to validate_on_submit can be used
form['csrf_token'].data = request.cookies['csrf_token']
if form.validate_on_submit():
print('>>>>>>> form validated:', form.data)
application = Application(
order_id=form.data['order_id'],
node_id=form.data['node_id'],
)
db.session.add(application)
db.session.commit()
return application.to_dict()
return 'invalid form'