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_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)