def boot(self, request: Request, response: Response):
"""Boots services required by the container."""
headers = config('middleware.cors') or {}
request.header(headers)
if request.get_request_method().lower() == 'options':
response.view('preflight')
def sign_in(self, request: Request, response: Response, auth: Auth,
validate: Validator):
errors = request.validate(validate.required("email"),
validate.required("password"))
if errors:
return errors
user_auth_res = auth.login(request.input("email"),
request.input("password"))
if user_auth_res is False:
return response.json({"error": "Check your credentials"})
msg = {
"id": user_auth_res.id,
"email": user_auth_res.email,
"name": user_auth_res.name,
"govId": user_auth_res.gov_id,
"type": user_auth_res.type,
}
enc = utils.encode_message(msg)
if enc != False:
return response.json({"access_token": enc.decode("utf-8")})
return response.json(
{"error": "You cannot access this system at the time"})
def setUp(self):
self.app = App()
self.request = Request(generate_wsgi()).load_app(self.app)
self.app.bind('Request', self.request)
self.app.bind('StatusCode', None)
self.response = Response(self.app)
self.app.bind('Response', self.response)
def store(self, view: View, request: Request, auth: Auth,
response: Response):
login = auth.attempt(request.input("username"),
request.input("password"))
if login:
return response.redirect(name="auth.home")
# Go back to login page
return response.redirect(name="login").with_errors(
["The email or password is incorrect"])
def show(self, request: Request, response: Response):
account_id = request.param("account_id")
blockchain_data = self.ibc.get_all_account_transactions(account_id)
blockchain_data = protobuf_to_dict(blockchain_data)
blockchain_data = utils.format_transaction_data(blockchain_data)
if blockchain_data is False:
return response.json({"error": "No such permissions"})
return response.json({"data": blockchain_data})
def store(self, request: Request, response: Response, validate: Validator):
errors = request.validate(
validate.required("symptoms"),
validate.required("diagnosis"),
validate.required("treatment_plan"),
validate.required("seen_by"),
)
if errors:
return errors
patient_id = request.param("patient_id")
patient_record = {
"author": f"{self.user.gov_id}@afyamkononi",
"timestamp": calendar.timegm(time.gmtime()),
"symptoms": request.input("symptoms"),
"diagnosis": request.input("diagnosis"),
"treatment_plan": request.input("treatment_plan"),
"seen_by": request.input("seen_by"),
}
patient_account = self.ibc.get_account_details(
request.param("patient_id"))
if patient_account.detail == "":
return response.json({"error": "No such account"})
unpacked_data = json.loads(patient_account.detail)
patient_history = utils.filter_medical_data(unpacked_data)
history_update = []
if patient_history == []:
history_update.append(patient_record)
else:
history_update += patient_history
history_update.append(patient_record)
history_update = utils.remove_duplicates(history_update)
blockchain_status = self.ibc.set_patient_record(
User.where("gov_id", patient_id).first(), history_update)
print(blockchain_status)
iroha_message = iroha_messages.update_medical_history_failed(
blockchain_status)
if iroha_message is not None:
return response.json(iroha_message)
return response.json({"success": "Medical data added successfully"})
def setUp(self):
self.app = App()
self.request = Request(wsgi_request).key(
'NCTpkICMlTXie5te9nJniMj9aVbPM6lsjeq5iDZ0dqY=').load_app(self.app)
self.app.bind('Request', self.request)
self.response = Response(self.app)
self.app.simple(Response)
def update(self, request: Request, response: Response):
channel = -1
level = -1
try:
print(f' channel 0: {request.all()["0"]}')
channel = 0
level = int(request.all()["0"])
except KeyError:
try:
print(f' channel 1: {request.all()["1"]}')
channel = 1
level = int(request.all()["1"])
except KeyError:
print('channel not found')
print(f' setting channel: {channel} to value: {level}')
try:
set_lights(channel, level)
message = 'OK'
except Exception:
message = 'connection error'
# return request.all()
return response.redirect('/')
def setUp(self):
self.app = App()
self.app.bind('Environ', generate_wsgi())
self.app.bind('Application', application)
self.app.make('Environ')
self.app.bind('StatusCode', None)
self.app.bind('Request',
Request(self.app.make('Environ')).load_app(self.app))
self.app.simple(Response(self.app))
self.app.bind('Csrf', Csrf(self.app.make('Request')))
self.app.bind('Route', Route(self.app.make('Environ')))
self.app.bind('ViewClass', View(self.app))
self.app.bind(
'WebRoutes',
[Get().route('/', 'TestController@show').middleware('test')])
self.app.bind('HttpMiddleware', [MiddlewareHttpTest])
self.app.bind('RouteMiddleware', {
'test': MiddlewareTest,
'throttle:1,2': MiddlewareValueTest
})
self.provider = RouteProvider()
self.provider.app = self.app
def show(self, request: Request, response: Response):
"""
Retrieve medical records for a patient
"""
subject = User.where("gov_id", request.param("patient_id")).first()
if subject is None:
return response.json({"error": "No such user"})
requestor_id = f"{self.user.gov_id}@afyamkononi"
grantor_id = f"{subject.gov_id}@afyamkononi"
consent_confirm = (Consent.where("requestor_id", requestor_id).where(
"grantor_id", grantor_id).where("grantor_id", "!=",
requestor_id).first())
if consent_confirm is None and requestor_id != grantor_id:
consent = Consent()
consent.requestor_id = requestor_id
consent.requestor_name = self.user.name
consent.grantor_id = grantor_id
consent.grantor_name = subject.name
consent.permission = "can_set_my_account_detail"
consent.save()
return response.json({
"error":
"No such permissions. This owner has been requested to grant permissions."
})
elif (consent_confirm is not None
and consent_confirm.grantor_id != requestor_id
and consent_confirm.status != "granted"):
consent_confirm.update(status="pending")
return response.json({
"error":
"No such permissions. This owner has been requested to grant permissions."
})
blockchain_data = self.ibc.get_account_details(subject.gov_id,
"medical_data")
if blockchain_data.detail == "":
return response.json({"data": []})
patient_medical_history = json.loads(blockchain_data.detail)
filtered_patient_medical_history = utils.filter_medical_data(
patient_medical_history)
return response.json({"data": filtered_patient_medical_history})
def role_permissions(self, request: Request, response: Response):
role_id = request.param("role")
blockchain_data = self.ibc.get_role_permissions(role_id)
blockchain_data = protobuf_to_dict(
blockchain_data.role_permissions_response)
return response.json({"data": blockchain_data})
def store(self, auth: Auth, request: Request,
response: Response): # store register user
errors = request.validate({
"email": "required",
"name": "required",
"password": "******",
})
if errors:
return response.back().with_errors(errors)
user = auth.register(request.only("name", "email", "password"))
if not user:
return response.redirect("/register")
return response.redirect("/home")
def setUp(self):
self.app = App()
self.app.bind('StatusCode', '404 Not Found')
self.app.bind(
'Request',
Request(None).load_app(self.app).load_environ(generate_wsgi()))
self.app.simple(Response(self.app))
self.app.bind('ViewClass', View(self.app))
self.app.bind('View', self.app.make('ViewClass').render)
def revoke_edit_permissions(self, request: Request, response: Response):
subject = User.where("gov_id", request.input("gov_id")).first()
grantor = User.where("gov_id", request.param("user")).first()
if subject is None:
return response.json({"error": "No such user"})
blockchain_status = self.ibc.revoke_edit_permissions(subject)
iroha_message = iroha_messages.revoke_set_account_detail_perms_failed(
blockchain_status)
if iroha_message is not None:
return response.json(iroha_message)
(Consent.where("requestor_id", f"{subject.gov_id}@afyamkononi").where(
"grantor_id",
f"{grantor.gov_id}@afyamkononi").update(status="revoked"))
return response.json(
{"success": "The requested permissions were revoked"})
def user_by_gov_id(self, request: Request, response: Response):
subject = User.where("gov_id", request.param("user")).first()
if subject is None:
return response.json({"error": "No such user"})
requestor_id = f"{self.user.gov_id}@afyamkononi"
grantor_id = f"{subject.gov_id}@afyamkononi"
consent_confirm = (Consent.where("requestor_id", requestor_id).where(
"grantor_id", grantor_id).first())
if consent_confirm is None and requestor_id != grantor_id:
consent = Consent()
consent.requestor_id = requestor_id
consent.requestor_name = self.user.name
consent.grantor_id = grantor_id
consent.grantor_name = subject.name
consent.permission = "can_set_my_account_detail"
consent.save()
return response.json({
"error":
"No such permissions. This owner has been requested to grant permissions."
})
elif (consent_confirm is not None
and consent_confirm.grantor_id != requestor_id
and consent_confirm.status != "granted"):
consent_confirm.update(status="pending")
return response.json({
"error":
"No such permissions. This owner has been requested to grant permissions."
})
data = self.ibc.get_account_details(subject.gov_id)
if data.detail == "":
return response.json({
"error":
"No such permissions. This owner has been requested to grant permissions."
})
return utils.format_query_result(data)
def delete(self, request: Request, response: Response):
"""Logic to delete data from a given model
"""
if self.before_crud_check(request, response) == False:
return response.json(None, status=403)
record = self.model.find(request.param('id'))
if record:
record.delete()
return record
return {'error': 'Record does not exist'}
def delete(self, request: Request, response: Response):
"""Logic to delete data from a given model
"""
if AdminMiddleware(request, response).checkpw_resource() == False:
return response.json(None, status=403)
record = self.model.find(request.param('id'))
if record:
record.delete()
return record
return {'error': 'Record does not exist'}
def setup_method(self):
self.app = App()
self.app.bind('Application', ApplicationMock)
self.app.bind('Environ', generate_wsgi())
self.app.bind('WebRoutes', [])
self.app.bind('View', View(self.app).render)
self.app.bind('Request', Request(generate_wsgi()).load_app(self.app))
self.app.simple(Response(self.app))
self.app.bind('StatusCode', None)
self.app.bind('Storage', StorageMock)
self.app.bind('ExceptionHandler', ExceptionHandler(self.app))
self.app.bind('HookHandler', Hook(self.app))
self.app.bind('Request', Request(generate_wsgi()).load_app(self.app))
self.app.bind('ExceptionAttributeErrorHandler', MockExceptionHandler)
def update(self, request: Request, response: Response):
"""Logic to update data from a given model
"""
if AdminMiddleware(request, response).checkpw_resource() == False:
return response.json(None, status=403)
record = self.model.where('id', request.param('id'))
params = request.all()
del params['login_id'], params['login_token']
try:
record.update(params)
except Exception as e:
return {'error': str(e)}
return {
} #self.model.where('id', request.param('id')).get().serialize()
def register(self):
self.app.bind('HookHandler', Hook(self.app))
self.app.bind('WebRoutes', flatten_routes(web.ROUTES))
self.app.bind('Storage', storage)
self.app.bind('Route', Route())
self.app.bind('Request', Request())
self.app.simple(Response(self.app))
self.app.bind('Container', self.app)
self.app.bind('ExceptionHandler', ExceptionHandler(self.app))
self.app.bind('ExceptionDumpExceptionHandler', DumpHandler)
self.app.bind('RouteMiddleware', middleware.ROUTE_MIDDLEWARE)
self.app.bind('HttpMiddleware', middleware.HTTP_MIDDLEWARE)
# Insert Commands
self._load_commands()
self._autoload(application.AUTOLOAD)
def redirect(self, response: Response):
""" Redirect to Google """
if self.scopes:
scopes = ' '.join(self.scopes)
else:
scopes = ''
params = dict(
scope=scopes,
access_type='offline',
redirect_uri=self._config['redirect'],
response_type='code',
client_id=self._config['client']
)
endpoint = f'{self.authorization_url}?{urllib.parse.urlencode(params)}'
return response.redirect(endpoint)
def setup_method(self):
self.app = App()
self.app.bind('Container', self.app)
self.app.bind('Environ', generate_wsgi())
self.app.bind('Application', application)
self.app.bind('WebRoutes', [])
self.app.bind('Route', Route(self.app.make('Environ')))
self.app.bind('Request', Request(
self.app.make('Environ')).load_app(self.app))
self.app.simple(Response(self.app))
self.app.bind('StatusCode', '404 Not Found')
self.app.bind('HttpMiddleware', middleware.HTTP_MIDDLEWARE)
view = View(self.app)
self.app.bind('ViewClass', view)
self.app.bind('View', view.render)
self.provider = RouteProvider()
self.provider.app = self.app
def index(self, request: Request, response: Response):
"""Logic to read data from several models
"""
if AdminMiddleware(request, response).checkpw_resource() == False:
return response.json(None, status=403)
# pagenagion
items = request.input('i') if request.input('i') else 10
page = request.input('p') if request.input('p') else 1
_offset = items * (page - 1)
if self.list_display:
results = self.model.select(
'id', *self.list_display).offset(_offset).limit(items).get()
new_results = [result._original for result in results._items]
return self.arr_iso_format(new_results)
#return self.model.select('id', *self.list_display).paginate(items, page).serialize()
else:
results = self.model.offset(_offset).limit(items).get()
new_results = [result._original for result in results._items]
return self.arr_iso_format(new_results)
def setUp(self):
self.app = App()
self.app.bind('Container', self.app)
self.app.bind('Environ', generate_wsgi())
self.app.bind('Application', application)
self.app.bind('WebRoutes', [])
self.app.bind('Route', Route(self.app.make('Environ')))
self.app.bind('Request',
Request(self.app.make('Environ')).load_app(self.app))
self.app.simple(Response(self.app))
self.app.bind('StatusCode', None)
self.app.bind('HttpMiddleware', middleware.HTTP_MIDDLEWARE)
view = View(self.app)
self.app.bind('ViewClass', view)
self.app.bind('View', view.render)
self.app.bind('Auth', Auth)
self.app.bind('Csrf', Csrf(self.app.make('Request')))
self.app.bind('AuthCookieDriver', AuthCookieDriver)
self.app.bind('AuthManager', AuthManager(self.app).driver('cookie'))
self.provider = RouteProvider()
self.provider.app = self.app
def register(self):
from routes import web
self.app.bind('HookHandler', Hook(self.app))
self.app.bind('WebRoutes', flatten_routes(web.ROUTES))
self.app.bind('Storage', config('storage'))
self.app.bind('Route', Route())
self.app.bind('Request', Request())
self.app.simple(Response(self.app))
self.app.bind('Container', self.app)
self.app.bind('ExceptionHandler', ExceptionHandler(self.app))
self.app.bind('ExceptionDumpExceptionHandler', DumpHandler)
self.app.bind('AuthCookieDriver', AuthCookieDriver)
self.app.bind('AuthJwtDriver', AuthJwtDriver)
self.app.bind('AuthManager', AuthManager(self.app).driver('cookie'))
self.app.bind('RouteMiddleware', config('middleware.route_middleware'))
self.app.bind('HttpMiddleware', config('middleware.http_middleware'))
self.app.bind('Auth', Auth)
# Insert Commands
self._load_commands()
self._autoload(config('application.autoload'))
def show(self, request: Request, response: Response):
"""Logic to read data from 1 model
"""
if AdminMiddleware(request, response).checkpw_resource() == False:
return response.json(None, status=403)
if self.detail_display and env('DB_CONNECTION') == 'mysql':
result = self.model.select(*self.detail_display).find(
request.param('id'))
new_result = {i: v for i, v in result._original.items()}
return self.arr_iso_format(new_result)
elif self.detail_display:
if 'id' not in self.detail_display:
self.detail_display.insert(0, 'id')
result = self.model.select(*self.detail_display).find(
request.param('id'))
new_result = {i: v for i, v in result._original.items()}
return self.arr_iso_format(new_result)
else:
result = self.model.find(request.param('id'))
new_result = {i: v for i, v in result._original.items()}
return self.arr_iso_format(new_result)
def create(self, request: Request, response: Response):
"""Logic to create data from a given model
"""
if AdminMiddleware(request, response).checkpw_resource() == False:
return response.json(None, status=403)
try:
params = request.all()
del params['login_id'], params['login_token']
config_model = AdminController.get_model_row_by_model_name(
self.model.__doc__.split(' ')[0])
new_model = self.model()
for key, value in params.items():
try:
setattr(new_model, key, value)
except Exception as e:
print(e)
new_model.save()
except Exception as e:
return {'error': str(e)}
return new_model
def test_json(self, response: Response):
return response.json({'test': 'value'})
def redirect(self, response: Response):
return response.redirect('/some/test')
def response_int(self, response: Response):
return response.view(1)
