def get(self):
opportunities = Opportunity.query.all()
if not is_authorized_with_permission('view:opportunity-internal'):
return unauthorized()
opp_list = opportunities_internal_schema.dump(opportunities)
return {'status': 'success', 'data': opp_list}, 200
return {'status': 'success', 'data': 'Hello World'}, 200
def post(self):
if not is_authorized_with_permission('write:all-users'):
return unauthorized()
json_data = request.get_json(force=True)
try:
data = contacts_short_schema.load(json_data)
except ValidationError as e:
return e.messages, 422
if not data:
return {'message': 'No data provided to update'}, 400
# Check that all of the contacts are in the db
contact_ids = [c['id'] for c in data]
contacts = Contact.query.filter(Contact.id.in_(contact_ids)).all()
if len(data) != len(contacts):
return {
'message': ("Payload contained contacts "
"that couldn't be found")
}, 404
# Update the stage of each contact
for contact in contacts:
contact.stage = ContactStage.approved.value
db.session.commit()
# Format and return the contacts
result = contacts_short_schema.dump(contacts)
return {'status': 'success', 'data': result}, 201
def get(self):
if not is_authorized_with_permission('view:all-users'):
return unauthorized()
contacts = Contact.query.all()
contacts = contacts_schema.dump(contacts)
return {'status': 'success', 'data': contacts}, 200
def delete(self, contact_id):
if not is_authorized_with_permission('delete:all-users'):
return unauthorized()
contact = Contact.query.get(contact_id)
if not contact:
return {'message': 'Contact does not exist'}, 404
db.session.delete(contact)
db.session.commit()
return {"status": 'success'}, 200
def delete(self, opportunity_id):
opportunity = Opportunity.query.get(opportunity_id)
if not opportunity:
return {'message': 'Opportunity does not exist'}, 404
if not is_authorized_with_permission('write:opportunity'):
return unauthorized()
db.session.delete(opportunity)
db.session.commit()
result = opportunity_schema.dump(opportunity)
return {"status": 'success'}, 200
def post(self, opportunity_id):
opportunity = Opportunity.query.get(opportunity_id)
if not opportunity:
return {'message': 'Opportunity does not exist'}, 404
if not is_authorized_with_permission('write:opportunity'):
return unauthorized()
opportunity.is_active = True
db.session.commit()
result = opportunity_schema.dump(opportunity)
return {'status': 'success', 'data': result}, 200
def get(self):
if not is_authorized_with_permission('view:all-users'):
return unauthorized()
approved_arg = request.args.get('is_approved')
if not approved_arg:
contacts = Contact.query.all()
else:
if approved_arg == 'true':
contacts = Contact.query.filter(Contact.stage >= 3)
elif approved_arg == 'false':
contacts = Contact.query.filter(Contact.stage < 3)
contacts = program_app_many_schema.dump(contacts)
return {'status': 'success', 'data': contacts}, 200
def get(self):
if not is_authorized_with_permission('view:app-internal'):
return unauthorized()
program_id = request.args.get('program_id')
if program_id:
program = Program.query.get(program_id)
if not program:
return {'message': 'Program does not exist'}, 404
program_contacts = [c for c in program.contacts if c.is_approved]
else:
program_contacts = ProgramContact.query.filter_by(is_approved=True)
result = program_contacts_short_schema.dump(program_contacts)
return {'status': 'success', 'data': result}, 200
def post(self):
json_data = request.get_json(force=True)
if not is_authorized_with_permission('write:opportunity'):
return unauthorized()
try:
data = opportunity_schema.load(json_data)
except ValidationError as e:
return e.messages, 422
# Make a new random id
opportunity = create_new_opportunity(data)
result = opportunity_schema.dump(opportunity)
return {"status": 'success', 'data': result}, 201
def post(self, contact_id, opportunity_id):
if not is_authorized_with_permission("write:app"):
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.draft.value:
return {'message': 'Application is already open for editing'}, 400
opportunity_app.stage = ApplicationStage.draft.value
db.session.commit()
result = opportunity_app_schema.dump(opportunity_app)
return {'status': 'success', 'data': result}, 200
def get(self):
if not is_authorized_with_permission('view:all-users'):
return unauthorized()
status = request.args.get('status')
status_list = ContactStage.__members__
if not status:
contacts = Contact.query.all()
elif status not in status_list:
return {
'message':
f'{status} is not a valid stage '
f'choose an option from this list: {status_list}'
}, 400
else:
contacts = (Contact.query.filter_by(
stage=ContactStage[status].value))
contacts = contacts_short_schema.dump(contacts)
return {'status': 'success', 'data': contacts}, 200
def put(self, opportunity_id):
opportunity = Opportunity.query.get(opportunity_id)
if not opportunity:
return {'message': 'Opportunity does not exist'}, 404
if not is_authorized_with_permission('write:opportunity'):
return unauthorized()
json_data = request.get_json(force=True)
try:
data = opportunity_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(opportunity, k, v)
db.session.commit()
result = opportunity_schema.dump(opportunity)
return {'status': 'success', 'data': result}, 200
def get(self):
if not is_authorized_with_permission('view:all-users'):
return unauthorized()
approved_arg = request.args.get('is_approved')
if not approved_arg:
contacts = Contact.query.all()
else:
if approved_arg == 'true':
contacts = (
Contact.query
.join(Contact.programs, aliased=True)
.filter(ProgramContact.is_approved==True)
)
elif approved_arg == 'false':
contacts = (
Contact.query
.join(Contact.programs, aliased=True)
.filter(~Contact.programs
.any(ProgramContact.is_approved==True))
)
contacts = contact_program_schema.dump(contacts)
return {'status': 'success', 'data': contacts}, 200
def post(self, program_id):
if not is_authorized_with_permission('write:all-users'):
return unauthorized()
json_data = request.get_json(force=True)
try:
data = contacts_short_schema.load(json_data)
except ValidationError as e:
return e.messages, 422
if not data:
return {'message': 'No data provided to update'}, 400
contact_ids = [c['id'] for c in data]
contacts = Contact.query.filter(Contact.id.in_(contact_ids)).all()
if len(data) != len(contacts):
return {
'message': ("Payload contained contacts "
"that couldn't be found")
}, 404
program_contacts = []
for contact in contacts:
program_contact = contact.query_program_contact(program_id)
if not program_contact:
insert_data = {
'contact_id': contact.id,
'program_id': program_id,
'is_approved': True
}
program_contact = create_program_contact(**insert_data)
program_contact.contact = contact
else:
program_contact.is_approved = True
program_contacts.append(program_contact)
db.session.commit()
result = program_contacts_short_schema.dump(program_contacts)
return {'status': 'success', 'data': result}, 200
def post(self):
if not is_authorized_with_permission('view:all-users'):
return unauthorized()
json_data = request.get_json(force=True)
query = input_schema.load(json_data)
try:
data = input_schema.load(json_data)
except ValidationError as e:
return e.messages, 422
q = (db.session
.query(Contact)
.join(Contact.profile)
.join(Contact.race)
.join(Contact.address_primary)
.with_entities(
Contact.id,
Contact.first_name,
Contact.last_name,
Contact.email,
Contact.phone_primary,
Contact.stage,
Profile.years_exp,
Profile.job_search_status,
Profile.gender,
ContactAddress.city,
ContactAddress.state,
Race.race_all,
))
if not query:
q = q.filter(Contact.stage > 1)
else:
# pops out stage and updates query with stage
status_list = query.pop('status', None)
if status_list == ['submitted']:
q = q.filter(Contact.stage == 2)
elif status_list == ['approved']:
q = q.filter(Contact.stage == 3)
else:
q = q.filter(Contact.stage > 1)
# pops out roles and adds them to the filter
roles = query.pop('roles', None)
if roles:
q = q.join(Profile.roles)
for r in roles:
q = q.filter(getattr(RoleChoice, r)==roles[r])
# pops out programs_completed and adds them to the filter
p_complete = query.pop('programs_completed', None)
if p_complete:
q = q.join(Profile.programs_completed)
for p in p_complete:
q = q.filter(getattr(ProgramsCompleted, p)==p_complete[p])
# pops out program_apps and adds them to the filter
app_params = query.pop('program_apps', None)
if app_params:
programs = [app['program']['id'] for app in app_params]
# uses subquery to prevent duplicate contacts
# from being returned
subq = (db.session
.query(ProgramApp.contact_id)
.filter(ProgramApp.program_id.in_(programs))
.filter(ProgramApp.is_interested==True)
.subquery())
q = q.filter(Contact.id.in_(subq))
# pops out skills and adds them to the filter
skill_params = query.pop('skills', None)
if skill_params:
skills = [get_skill_id(skill) for skill in skill_params]
# uses subquery to prevent duplicate contacts
# from being returned
subq = (db.session
.query(ContactSkill.contact_id)
.filter(ContactSkill.skill_id.in_(skills))
.filter(ContactSkill.deleted==False)
.subquery())
q = q.filter(Contact.id.in_(subq))
# iteratively adds query parameters to query for Profile
for param in query:
q = q.filter(getattr(Profile, param).in_(query[param]))
result = [format_row(row) for row in q.all()]
return {'status': 'success', 'data': result}, 201
