def put(self, contact_id):
contact = Contact.query.get(contact_id)
if not contact:
return {'message': 'Contact does not exist'}, 404
if not is_authorized_write(contact.id):
return unauthorized()
json_data = request.get_json(force=True)
try:
data = contact_schema.load(json_data, partial=True)
except ValidationError as e:
return e.messages, 422
if not data:
return {'message': 'No input data provided'}, 400
email = data.pop('email_primary', None)
email_list = data.pop('emails', None)
skills = data.pop('skills', None)
contact.update(**data)
if email:
del contact.emails[:]
contact.email_primary = Email(**email)
if skills:
sync_skills(skills, contact)
db.session.commit()
result = contact_schema.dump(contact)
return {"status": 'success', 'data': result}, 200
def put(self, contact_id, opportunity_id):
if not is_authorized_write(contact_id):
return unauthorized()
json_data = request.get_json(force=True)
try:
data = opportunity_app_schema.load(json_data, partial=True)
except ValidationError as e:
return e.messages, 422
if not data:
return {'message': 'No data provided to update'}, 400
opportunity_app = (OpportunityApp.query
.filter_by(contact_id=contact_id, opportunity_id=opportunity_id)
.first())
if not opportunity_app:
return {'message': 'Application does not exist'}, 404
if data.get('resume') is not None:
if opportunity_app.resume is None:
opportunity_app.resume = ResumeSnapshot(
**data['resume']
)
else:
opportunity_app.resume.resume = data['resume']['resume']
del data['resume']
opportunity_app.update(**data)
db.session.commit()
result = opportunity_app_schema.dump(opportunity_app)
return {'status': 'success', 'data': result}, 200
def post(self, contact_id, capability_id):
if not is_authorized_write(contact_id):
return unauthorized()
json_data = request.get_json(force=True)
try:
data = skill_schema.load(json_data)
except ValidationError as e:
return e.messages, 422
contact = Contact.query.get(contact_id)
if not contact:
return {'message': 'Contact does not exist'}, 404
capability = Capability.query.get(capability_id)
if not capability:
return {'message': 'Capability does not exist'}, 404
skill = get_or_make_skill(data['name'])
if skill not in contact.skills:
contact.add_skill(skill)
suggestion = CapabilitySkillSuggestion(
skill_id=skill.id,
contact_id=contact_id,
capability_id=capability_id)
db.session.add(suggestion)
db.session.commit()
result = dump_skill_with_capabilities(skill, contact_id)
return {'status': 'success', 'data': result}, 201
def put(self, resume_id, section_id):
res = Resume.query.get(resume_id)
if not res:
return {'message': 'Resume does not exist'}, 404
if not is_authorized_write(res.contact.id):
return unauthorized()
section = ResumeSection.query.get(section_id)
if not section:
return {'message': 'Resume section does not exist'}, 404
json_data = request.get_json(force=True)
try:
data = resume_section_schema.load(json_data, partial=True)
except ValidationError as e:
return e.messages, 422
if not data:
return {'message': 'No input data provided'}, 400
items = data.pop('items', None)
for k,v in data.items():
setattr(section, k, v)
del section.items[:]
if items:
for item in items:
i = ResumeItem(**item)
i.resume_id = section.resume_id
section.items.append(i)
db.session.commit()
result = resume_section_schema.dump(section)
return {'status': 'success', 'data': result}, 200
def post(self, contact_id):
if not is_authorized_write(contact_id):
return unauthorized()
json_data = request.get_json(force=True)
try:
data = skill_schema.load(json_data)
except ValidationError as e:
return e.messages, 422
if not data:
return {'message': 'No input data provided'}, 400
contact = Contact.query.get(contact_id)
if not contact:
return {'message': 'Contact not found'}, 404
name = data['name']
skill = get_or_make_skill(name)
contact_skill_names = {s.name for s in contact.skills}
status_code = 200
if name not in contact_skill_names:
status_code = 201
contact.add_skill(skill)
db.session.commit()
result = dump_skill_with_capabilities(skill, contact_id)
return {'status': 'success', 'data': result}, status_code
def put(self, contact_id):
if not is_authorized_write(contact_id):
return unauthorized()
json_data = request.get_json(force=True)
contact = Contact.query.get(contact_id)
if not contact:
return {'message': 'Contact does not exist'}, 404
try:
data = profile_schema.load(json_data)
except ValidationError as e:
return e.messages, 422
profile_data = data.pop('profile', None)
contact.update(**data)
contact.profile.update(**profile_data)
email = data.get('email', None)
if email:
contact.email_primary.email = email
db.session.commit()
result = profile_schema.dump(contact)
return {'status': 'success', 'data': result}, 200
def post(self, contact_id):
if not is_authorized_write(contact_id):
return unauthorized()
#load the input data
input_data = request.get_json(force=True)
try:
data = resume_generate_schema.load(input_data)
except ValidationError as e:
return e.messages, 422
if not data:
return {'message': 'No input data provided'}, 400
#pop off the ids for the data in each of the sections
relevant_exp = data.pop('relevant_exp', None)
other_exp = data.pop('other_exp', None)
relevant_edu = data.pop('relevant_edu', None)
other_edu = data.pop('other_edu', None)
relevant_achieve = data.pop('relevant_achieve', None)
other_achieve = data.pop('other_achieve', None)
relevant_skills = data.pop('relevant_skills', None)
other_skills = data.pop('other_skills', None)
#query and add contact info to input data
data['contact'] = Contact.query.get(contact_id)
#query subset of resume items using lists of ids then
#add those items to the input data with their section name
def query_by_ids(table, id_list, contact_id, section_name):
result = table.query.filter(table.id.in_(id_list),
table.contact_id==contact_id)
data[section_name] = result
query_by_ids(Experience, relevant_exp, contact_id, 'relevant_exp_dump')
query_by_ids(Experience, other_exp, contact_id, 'other_exp_dump')
query_by_ids(Experience, relevant_edu, contact_id, 'relevant_edu_dump')
query_by_ids(Experience, other_edu, contact_id, 'other_edu_dump')
query_by_ids(Experience, relevant_achieve, contact_id, 'relevant_achieve_dump')
query_by_ids(Experience, other_achieve, contact_id, 'other_achieve_dump')
query_by_ids(TagItem, relevant_skills, contact_id, 'relevant_skills_dump')
query_by_ids(TagItem, other_skills, contact_id, 'other_skills_dump')
#dumps the throughput data and pass to generate resume script
throughput_data = resume_generate_schema.dump(data)
pprint(throughput_data)
gdoc_id = generate(throughput_data)
#creates dictionary to insert new resume record
output_data = {
'name': data['name'],
'date_created': dt.datetime.today(),
'contact_id': contact_id,
'gdoc_id': gdoc_id,
}
resume = Resume(**output_data)
db.session.add(resume)
db.session.commit()
result = resume_output_schema.dump(resume)
return {'status': 'success', 'data': result}, 201
def delete(self, resume_id):
res = Resume.query.get(resume_id)
if not res:
return {'message': 'Resume does not exist'}, 404
if not is_authorized_write(res.contact.id):
return unauthorized()
db.session.delete(res)
db.session.commit()
return {'status': 'success'}, 200
def delete(self, contact_id, program_id):
if not is_authorized_write(contact_id):
return unauthorized()
program_contact = query_one_program_contact(contact_id, program_id)
if not program_contact:
return {'message': 'Program contact does not exist'}, 404
db.session.delete(program_contact)
db.session.commit()
return {"status": 'success'}, 200
def delete(self, contact_id, tag_id):
if not is_authorized_write(contact_id):
return unauthorized()
tag = TagItem.query.filter_by(contact_id=contact_id,
tag_id=tag_id).first()
if not tag:
return {'message': 'TagItem does not exist'}, 404
db.session.delete(tag)
db.session.commit()
return {'status': 'success'}, 201
def delete(self, contact_id, capability_id, skill_id):
if not is_authorized_write(contact_id):
return unauthorized()
(result, status_code) = delete_skill(contact_id, skill_id)
if status_code != 200:
return result, status_code
suggestion = CapabilitySkillSuggestion.query.get(
(contact_id, capability_id, skill_id))
if suggestion is not None:
db.session.delete(suggestion)
db.session.commit()
return {'status': 'success'}, 200
def post(self, contact_id):
if not is_authorized_write(contact_id):
return unauthorized()
json_data = request.get_json(force=True)
try:
data = resume_schema.load(json_data)
except ValidationError as e:
return e.messages, 422
if not data:
return {'message': 'No input data provided'}, 400
res = Resume(**data)
db.session.add(res)
db.session.commit()
result = resume_schema.dump(res)
return {'status': 'success', 'data': result}, 201
def post(self, contact_id, opportunity_id):
if not is_authorized_write(contact_id):
return unauthorized()
opportunity_app = (OpportunityApp.query
.filter_by(contact_id=contact_id, opportunity_id=opportunity_id)
.first())
if not opportunity_app:
return {'message': 'Application does not exist'}, 404
if opportunity_app.stage >= ApplicationStage.submitted.value:
return {'message': 'Application is already submitted'}, 400
opportunity_app.stage = ApplicationStage.submitted.value
db.session.commit()
result = opportunity_app_schema.dump(opportunity_app)
return {'status': 'success', 'data': result}, 200
def put(self, resume_id):
res = Resume.query.get(resume_id)
if not res:
return {'message': 'Resume does not exist'}, 404
if not is_authorized_write(res.contact.id):
return unauthorized()
json_data = request.get_json(force=True)
try:
data = resume_schema.load(json_data, partial=True)
except ValidationError as e:
return e.messages, 422
if not data:
return {'message': 'No data provided to update'}, 400
for k,v in data.items():
setattr(res, k, v)
db.session.commit()
result = resume_schema.dump(res)
return {'status': 'success', 'data': result}, 200
def put(self, contact_id, tag_id):
if not is_authorized_write(contact_id):
return unauthorized()
tag = (TagItem.query.filter_by(contact_id=contact_id,
tag_id=tag_id).first())
if not tag:
return {'message': 'TagItem does not exist'}, 404
json_data = request.get_json(force=True)
try:
data = tag_item_schema.load(json_data, partial=True)
except ValidationError as e:
return e.messages, 422
if not data:
return {'message': 'No data provided to update'}, 400
for k, v in data.items():
setattr(tag, k, v)
db.session.commit()
result = tag_item_schema.dump(tag)
return {'status': 'success', 'data': result}, 200
def post(self, contact_id):
if not is_authorized_write(contact_id):
return unauthorized()
#retrieve and parse request data
json_data = request.get_json(force=True)
try:
data = program_contact_schema.load(json_data)
except ValidationError as e:
return e.messages, 422
if not data:
return {'message': 'No data provided to update'}, 400
# checks to see if there's an existing program_contact record
program = data.pop('program_id')
contact = data.pop('contact_id')
program_contact = create_program_contact(contact_id,
program_id=program,
**data)
db.session.commit()
result = program_contact_schema.dump(program_contact)
return {"status": 'success', 'data': result}, 201
def post(self, contact_id, opportunity_id):
if not is_authorized_write(contact_id):
return unauthorized()
opportunity_app = (OpportunityApp.query
.filter_by(contact_id=contact_id, opportunity_id=opportunity_id)
.first())
if opportunity_app:
return {'message': 'Application already exists!'}, 400
opportunity_app = OpportunityApp(
id=str(uuid.uuid4()),
contact_id=contact_id,
opportunity_id=opportunity_id,
interest_statement=''
)
db.session.add(opportunity_app)
db.session.commit()
data = opportunity_app_schema.dump(opportunity_app)
return {'status': 'success', 'data': data}, 201
def put(self, contact_id):
if not is_authorized_write(contact_id):
return unauthorized()
json_data = request.get_json(force=True)
contact = Contact.query.get(contact_id)
if not contact:
return {'message': 'Contact does not exist'}, 404
try:
data_raw = program_app_schema.load(json_data)
except ValidationError as e:
return e.messages, 422
data = data_raw.pop('program_apps', None)
if not data:
return {'message': 'No program data provided'}, 404
for item in data:
app = (ProgramApp.query.filter_by(
contact_id=contact_id,
program_id=item['program']['id']).first())
if app:
item.pop('is_approved', None)
app.update(**item)
else:
new_app = ProgramApp(contact_id=contact_id,
program_id=item['program']['id'],
is_interested=item['is_interested'])
contact.program_apps.append(new_app)
db.session.add(contact)
db.session.commit()
result = program_app_schema.dump(contact)
return {'status': 'success', 'data': result}, 200
def put(self, contact_id, program_id):
if not is_authorized_write(contact_id):
return unauthorized()
#retreives and parses request data
json = request.get_json(force=True)
try:
data = program_contact_schema.load(json, partial=True)
except ValidationError as e:
return e.messages, 422
if not data:
return {'message': 'No data provided to update'}, 400
# checks to make sure the record exists
program_contact = query_one_program_contact(contact_id, program_id)
if not program_contact:
return {'message': 'Record does not exist'}, 404
# updates program_contact record
program_contact.update(**data)
db.session.commit()
result = program_contact_schema.dump(program_contact)
return {"status": 'success', 'data': result}, 200
def delete(self, contact_id, skill_id):
if not is_authorized_write(contact_id):
return unauthorized()
return delete_skill(contact_id, skill_id)
