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 create(job):
schema = JobSchema()
new_job = schema.load(job, session=db.session)
db.session.add(new_job)
db.session.commit()
data = schema.dump(new_job)
return data, 201
def read_one(job_id):
job = (Job.query.filter(Job.job_id == job_id).one_or_none())
if job is not None:
job_schema = JobSchema()
data = job_schema.dump(job)
return data
else:
abort(404, "Job with ID {job_id} not found".format(job_id=job_id))
def read_all():
"""
This function responds to a request for /api/job
with the complete lists of job
:return: json string of list of job
"""
# Create the list of job from our data
job = Job.query.order_by(Job.job_id).all()
# Serialize the data for the response
job_schema = JobSchema(many=True)
data = job_schema.dump(job)
return data
def update(job_id, job):
update_job = Job.query.filter(Job.job_id == job_id).one_or_none()
if update_job is not None:
schema = JobSchema()
up = schema.load(job, session=db.session)
up.job_id = update_job.job_id
db.session.merge(up)
db.session.commit()
data = schema.dump(update_job)
return data, 200
else:
abort(404, f"Job not found for Id: {job_id}")
def read_one(job_id):
# Get the job requested
job = Job.query.filter(Job.job_id == job_id).one_or_none()
# Did we find a job?
if job is not None:
# Serialize the data for the response
job_schema = JobSchema()
data = job_schema.dump(job)
return data
# Otherwise, nope, didn't find that job
else:
abort(
404,
"Job not found for Id: {job_id}".format(job_id=job_id),
)
def create(job):
job_id = job.get("job_id")
app_name = job.get("app_name")
state = job.get("state")
existing_job = (Job.query.filter(Job.job_id == job_id).filter(
Job.app_name == app_name).filter(Job.state == state).one_or_none())
if existing_job is None:
# Create a job instance using the schema and the passed in job
schema = JobSchema()
new_job = schema.load(job, session=db.session)
# Add the job to the database
db.session.add(new_job)
db.session.commit()
# Serialize and return the newly created job in the response
data = schema.dump(new_job)
return data, 201
def list_jobs():
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.performer:
user_jobs = Job.query.filter_by(performer=user.performer)
job_schema = JobSchema(many=True)
job_output = job_schema.dump(user_jobs).data
else:
user_jobs = Job.query.filter_by(customer=user.customer)
job_schema = JobSchema(many=True)
job_output = job_schema.dump(user_jobs).data
else:
return "Invalid credentials"
return jsonify({'your jobs are': job_output})
def login():
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):
session["user_id"] = user.id
session["role"] = user.role
if user.performer:
performer_schema = PerformerSchema()
output = performer_schema.dump(user.performer).data
user_jobs = Job.query.filter_by(performer=user.performer)
job_schema = JobSchema(many=True)
job_output = job_schema.dump(user_jobs).data
for job in job_output:
job['performer_name'] = user.performer.name
job['performer_email'] = user.performer.email
customer_query = Customer.query.get(job['customer'])
job['customer_name'] = customer_query.name
job['customer_email'] = customer_query.email
else:
customer_schema = CustomerSchema()
output = customer_schema.dump(user.customer).data
user_jobs = Job.query.filter_by(customer=user.customer)
job_schema = JobSchema(many=True)
job_output = job_schema.dump(user_jobs).data
for job in job_output:
job['customer_name'] = user.customer.name
job['customer_email'] = user.customer.email
performer_query = Performer.query.get(job['performer'])
job['performer_name'] = performer_query.name
job['performer_email'] = performer_query.email
output['jobs'] = job_output
return jsonify({'user': output})
else:
return "Log in failed"
from flask import request
from flask_restful import Resource
from models import db, Job, JobSchema
from .helper import *
job_list_schema = JobSchema(many=True)
job_schema = JobSchema()
# Job
# shows a single job
class JobResource(Resource):
def get(self, jobID):
return generic_get_single(Job, jobID, job_schema)
# Delete Job
def delete(self, jobID):
job = Job.query.filter(Job.id == jobID).delete()
db.session.commit()
result = job_schema.dump(job).data
return result, 204
# Job List
# - get to show a list of all jobs
# - post to add a new job
# - put to edit a existing job
# - delete to delete job
def read_all():
job = Job.query.order_by(Job.job_id).all()
job_schema = JobSchema(many=True)
data = job_schema.dump(job)
return data