def employee_edit(emp_code):
data = request.get_json()
employee_to_edit = Employee.query.filter_by(code = emp_code).first()
try:
employee_to_edit.firstname = data['firstname']
employee_to_edit.middlename = data['middlename']
employee_to_edit.lastname = data['lastname']
employee_to_edit.address = data['address']
employee_to_edit.gender = data['gender']
employee_to_edit.code = data['code']
employee_to_edit.birthday = data['birthday']
employee_to_edit.position = data['position']
employee_to_edit.nationality = data['nationality']
employee_to_edit.status = data['status']
employee_to_edit.email = data['email']
employee_to_edit.contact_number = data['contact_number']
employee_to_edit.department = data['department']
#logs here
details = "Edited information of " + employee_to_edit.firstname + " " + employee_to_edit.lastname
new_log = Logs(log_date=dt.datetime.now(), log_details=details)
dbase.session.add(new_log)
dbase.session.commit()
#End log
return jsonify({'message': 'Information was edited Successfully!'})
except:
return jsonify({'message': 'The code is not available!'})
def employee_all():
employee_from_db = Employee.query.filter_by(employee_status=1).all()
data = []
if employee_from_db:
for i in employee_from_db:
employee = {}
employee['firstname'] = i.firstname
employee['middlename'] = i.middlename
employee['lastname'] = i.lastname
employee['birthday'] = str(i.birthday)
employee['address'] = i.address
employee['status'] = i.status
employee['nationality'] = i.nationality
employee['gender'] = i.gender
employee['code'] = i.code
employee['position'] = i.position
employee['contact_number'] = i.contact_number
employee['email'] = i.email
employee['department'] = i.department
employee['qr_url'] = i.qr_url
employee['profile_url'] = i.profile_url
data.append(employee)
return jsonify({'employee': data})
else:
return jsonify({'employee': data})
def get_countries():
countries = Country.query.all()
if len(countries) <= 0:
return jsonify({"message": "No data available"})
else:
# Returns all countries with covid-19 cases
return jsonify(
countries=[country.serialize_country() for country in countries])
def deletePatient(id):
checkRecord=Product.query.filter_by(id=id).count()
if checkRecord!=0:
getRecord=Product.query.get(id)
db.session.delete(getRecord)
db.session.commit()
return jsonify({'msg':'Patient Record deleted'})
else:
return jsonify({'msg':'Patient does not exists'})
def patch():
c1_json = request.get_json()
one_customer = session.query(Customer).filter(
Customer.email == c1_json["email"]).first()
if one_customer == None:
return (jsonify({"message": "Mail not found."}), 404)
else:
session.add(one_customer)
session.commit()
return (jsonify({}), 200)
def get_country(country_name):
country = Country.query.filter_by(name=normalize(country_name)).first()
if country is None:
return jsonify({"message": "data does not exist"})
else:
dict_country = country.serialize_country()
dict_country[
'url'] = "http://127.0.0.1:5000/covid19/api/v1/countries/{}/states".format(
rev_normalize(country.name))
# Returns a country with covid-19 cases given country_id
return jsonify({"country": dict_country})
def deletePatient(record):
print("Deleting record with name: ", request.json['name'])
print("Deleting record with name: ", request.json['id'])
hash = calHash(request.json['name'])
if redis.exists(hash) == 1:
redis.delete(hash)
print("Record deleted")
return jsonify({'msg': 'Patient Record deleted'})
ops_db_update_request()
else:
return jsonify({'msg': 'Patient does not exists'})
def getPatients():
cachedResults = redis.keys()
if not cachedResults:
all_Products = Product.query.all()
result = patients_schema.dump(all_Products)
for resu in result:
hash = calHash(resu["name"])
redis.set(hash, json.dumps(resu), 120)
return make_response(jsonify(result), 200)
else:
return make_response(jsonify(redis.mget(cachedResults)), 202)
def get_logs():
log = Logs.query.order_by(Logs.log_date.desc()).all()
logs = []
if log:
for i in log:
log_data = {}
log_data['logdetails'] = i.log_details
log_data['logdate'] = str(i.log_date)
logs.append(log_data)
return jsonify({'adminlogs': logs})
else:
return jsonify({'adminlogs': logs})
def post():
c1_json = request.get_json()
if session.query(Customer).filter(
Customer.email == c1_json["email"]).first() == None:
c1 = Customer(name=c1_json["name"],
address=c1_json["address"],
email=c1_json["email"])
session.add(c1)
session.commit()
return (jsonify({"message": "Successfully loaded."}), 200)
else:
return (jsonify({"message": "This email already exists."}), 404)
def permanent_remove(emp_code):
to_del = Employee.query.filter_by(code = emp_code).first()
if to_del:
#logs here
details = "Permanently removed " + to_del.firstname + " " + to_del.lastname
new_log = Logs(log_date=dt.datetime.now(), log_details=details)
dbase.session.add(new_log)
dbase.session.commit()
#End log
dbase.session.delete(to_del)
dbase.session.commit()
return jsonify({'message': 'Employee removed permanently!'})
return jsonify({'message': 'Operation failed!'})
def get_country_states(country_name):
country_name = normalize(country_name)
country = Country.query.filter_by(name=country_name).first()
if country is None:
return jsonify({"message": "data does not exist"})
else:
# Returns states for country with covid-19 cases given country_id
get_states = State.query.filter_by(country_name=country.name).all()
states = [state.serialize_state() for state in get_states]
return jsonify({
"country": country.serialize_country(),
"states": states
})
def delete():
c1_json = request.get_json()
try:
if Customer.check_user_existance_and_apply(c1_json, session):
session.delete(
session.query(Customer).filter(
Customer.email == c1_json["email"]).first())
session.commit()
return (jsonify({"Message": "User deleted."}), 200)
else:
return (jsonify({"Message": "User could not be found."}), 404)
except:
return (jsonify({"Message":
"The database could not be accesed."}), 500)
def delete_employee(emp_code):
employee_delete = Employee.query.filter_by(code = emp_code).first()
try:
#logs here
details = "Permanently removed " + employee_delete.firstname + " " + employee_delete.lastname
new_log = Logs(log_date=dt.datetime.now(), log_details=details)
dbase.session.add(new_log)
dbase.session.commit()
#End log
dbase.session.delete(employee_delete)
dbase.session.commit()
except:
return jsonify({'message': 'There was an error request failed!'})
return jsonify({'message': 'Employee was Deleted!'})
def remove_employee(emp_code):
employee_remove = Employee.query.filter_by(code = emp_code).first()
try:
#logs here
details = "Deactivated/Removed " + employee_remove.firstname + " " + employee_remove.lastname
new_log = Logs(log_date=dt.datetime.now(), log_details=details)
dbase.session.add(new_log)
dbase.session.commit()
#End log
employee_remove.employee_status = 0
dbase.session.commit()
except:
return jsonify({'message': 'There was an error request failed!'})
return jsonify({'message': 'Employee was deactivated!'})
def get_country_state(country_name, state_name):
country_name = normalize(country_name)
state_name = normalize(state_name)
country = Country.query.filter_by(name=country_name).first()
if country is None:
return jsonify({"message": "data does not exist"})
else:
# Returns state for country with covid-19 cases given country_id
state = State.query.filter_by(name=state_name).first()
state = state.serialize_state()
state[
'url'] = "http://127.0.0.1:5000/covid19/api/v1/countries/{}/states".format(
rev_normalize(country.name))
return jsonify({"state": state})
def request_overtime(emp_code):
try:
overtime_obj = Overtimelist(overtimer_code = emp_code, overtime_status = 0)
except:
return jsonify({'message': 'There was an error request failed!'})
dbase.session.add(overtime_obj)
dbase.session.commit()
def get():
c1_json = request.get_json()
try:
if Customer.check_user_existance_and_apply(c1_json, session):
a_user = session.query(Customer).filter(
Customer.email == c1_json["email"]).first()
return (jsonify({
"name": a_user.name,
"address": a_user.address,
"email": a_user.email
}), 200)
else:
return (jsonify({"Message": "User could not be found."}), 404)
except:
return (jsonify({"Message":
"The database could not be accesed."}), 500)
def get_task(task_id):
task = find_task(task_id)
if task is None:
abort(404)
result = task.wrap()
return jsonify(result)
def get_task(task_id):
task = find_task(task_id)
if task is None:
abort(404)
result = task.wrap()
return jsonify(result)
def get_link(link_id):
link = find_link(link_id)
if link is None:
abort(404)
result = link.wrap()
return jsonify(result)
def create_task():
if not request.json or not 'description' in request.json:
abort(400)
task = Task(description=request.json['description'], order=next_order(), done=False)
task.save()
result = task.wrap()
return jsonify(result), 201
def edit_time():
data = request.get_json()
to_edit = CompanyTime.query.filter_by(company_time_id = 1).first()
if to_edit:
to_edit.morning_time_in = dt.datetime.strptime(data['morning_time_in'], "%H:%M:%S")
to_edit.morning_time_out = dt.datetime.strptime(data['morning_time_out'], "%H:%M:%S")
to_edit.afternoon_time_in = dt.datetime.strptime(data['afternoon_time_in'], "%H:%M:%S")
to_edit.afternoon_time_out = dt.datetime.strptime(data['afternoon_time_out'], "%H:%M:%S")
dbase.session.commit()
#logs here
details = "Edited time In/Out."
new_log = Logs(log_date = dt.datetime.now(), log_details = details )
dbase.session.add(new_log)
dbase.session.commit()
#End log
return jsonify({'message':'Time changed successfully!'})
return jsonify({'message': 'Operation failed!'})
def not_found(e):
return jsonify({
"countries":
"https://covid19-datamap-api.herokuapp.com/covid19/api/v1/countries",
"country":
"https://covid19-datamap-api.herokuapp.com/covid19/api/v1/countries/<country_id>",
"error": "resource does not exist",
})
def create_link():
if not request.json or not 'source' in request.json:
abort(400)
link = Link(source=request.json['source'], target=request.json['target'], weight=request.json['weight'])
link.save()
result = link.wrap()
return jsonify(result), 201
def login():
data = request.get_json()
print data
admin = Admin.query.filter_by(username = data['username']).first()
if not admin:
return jsonify({'message': 'Invalid username or password'})
else:
if check_password_hash(admin.password, data['password']):
login_user(admin, remember=True)
#logs here
details = "Logged in"
new_log = Logs(log_date=dt.datetime.now(), log_details=details)
dbase.session.add(new_log)
dbase.session.commit()
#End log
return jsonify({'message': 'Login Successfully!'})
else:
return jsonify({'message': 'Invalid username or password'})
def createPatient():
"""
Below code will construct a dictonary with recieved variables in request
and will cache the record into redis memory
"""
hash = calHash(request.json['name'])
_tmpDict = {
"id": hash,
"name": request.json['name'],
"location": request.json['location'],
"streetname": request.json['streetname'],
"status": request.json['status']
}
if redis.exists(hash) == 0:
print("creating cache entry")
redis.set(hash, json.dumps(_tmpDict), 120)
return jsonify(_tmpDict)
else:
return jsonify({'name': 'patient already exists'})
def update_link(link_id):
link = find_link(link_id)
if link is None:
abort(404)
link.weight = request.json['weight']
link.save()
result = link.wrap()
return jsonify(result)
def strongify_password():
"""
This route will recive a password and return five password options
"""
params = request.json
password = params["password"]
try:
password_array = []
for i in range(0, 5):
new_password = strongify_service.strongify_password(
password=password)
password_array.append(new_password)
return jsonify({"msg": "success", "data": password_array})
except Exception as error:
return jsonify({"msg": "error", "data": str(error)})
def employee_add():
data = request.get_json()
check_avail = Employee.query.filter_by(code = data['code']).first()
if not check_avail:
new_employee = Employee(firstname=data['firstname'], middlename=data['middlename'],
lastname=data['lastname'], address=data['address'], gender=data['gender'], code=data['code'],
birthday = data['birthday'], position=data['position'], employee_status=1, nationality=data['nationality'], status=data['status'],
email=data['email'], contact_number=data['contact_number'], department=data['department'])
dbase.session.add(new_employee)
dbase.session.commit()
#logs here
details = "Added employee " + data['firstname'] + " " + data['lastname']
new_log = Logs(log_date=dt.datetime.now(), log_details=details)
dbase.session.add(new_log)
dbase.session.commit()
#End log
return jsonify({'message': 'Employee was added Successfully!'})
else:
return jsonify({'message': 'The code is not available employee already exist.'})
def post(self):
count = 0
for email in editors:
if is_editor(email):
continue
count += 1
e = Editor(email=email)
e.put()
reply = {'ok': True, 'added': count}
self.response.headers['Content-Type'] = 'application/json'
self.response.write(jsonify(reply))
def createPatient():
name=request.json['name']
location=request.json['location']
streetname=request.json['streetname']
status=request.json['status']
new_product=Product(name,location,streetname,status)
if db.session.query(Product).filter(Product.name==name).count() == 0:
db.session.add(new_product)
db.session.commit()
return patient_schema.jsonify(new_product)
else:
return jsonify({'name':'patient already exists'})
def update_task(task_id):
task = find_task(task_id)
if task is None:
abort(404)
if not valid_request(request):
abort(400)
task.description = request.json['description']
task.order = request.json['order']
task.done = request.json['done']
task.save()
result = task.wrap()
return jsonify(result)
def respond(self, obj):
self.response.headers['Content-Type'] = 'application/json'
self.response.write(jsonify(obj))
def delete_task(task_id):
task = find_task(task_id)
if task is None:
abort(404)
task.remove()
return jsonify({'result': True})
def get_tasks():
tasks = Task.query.ascending(Task.order).all()
results = []
for task in tasks:
results.append(task.wrap())
return jsonify(results)
