async def set_state(self, request):
"""
Relay set value
"""
relay, status = RelayController.try_intParse(
request.match_info['relay'])
if not status:
return web.HTTPNotFound(text="Relay not found")
state_in, status = RelayController.try_intParse(
request.match_info['state'])
if not status:
return web.HTTPNotFound(text="State invalid")
if state_in < 0 or state_in > 1:
return web.HTTPError()
relay_mapped = next((x for x in self.mapping if x['id'] == relay),
None)
if relay_mapped == None:
return web.HTTPError()
if relay_mapped['active'] == 'high':
self.gpio.get(relay_mapped['chip']).output(
relay_mapped['line'], HIGH if state_in else LOW)
elif relay_mapped['active'] == 'low':
self.gpio.get(relay_mapped['chip']).output(
relay_mapped['line'], LOW if state_in else HIGH)
return web.json_response({"status": "ok"})
async def del_redirect(request):
uri = request.match_info["uri"]
try:
await request.app["db"].del_redirect(uri)
return web.HTTPOk()
except:
return web.HTTPError()
async def post(self):
name, slug = await get_name_slug(self.request)
db, session = await get_base_needed(self.request)
data = await self.request.post()
token, user = session['token'], session['user']
whom_user = SITE_STORAGE[user]
status = await check_token(session_token=token,
html_token=data['csrf_token'])
if status:
password = data['password']
status = await Rooms.check_password(db=db,
username=whom_user,
name=name,
slug=slug,
password=password)
if status:
session['flag-password-iteration'] = 'pull-password'
del SITE_STORAGE[user]
location = self.request.app.router['current_room'].url_for(
name=name, slug=slug)
return web.HTTPFound(location=location)
else:
return web.HTTPFound(location='/messages')
else:
return web.HTTPError()
async def start_scanning(self, request):
await check_authorized(request)
try:
self.adapter.start_scan()
except Exception as exc:
return web.HTTPError(reason=str(exc))
return web.Response()
async def stop_discoverable(self, request):
await check_authorized(request)
try:
self.adapter.stop_discoverable()
except Exception as exc:
return web.HTTPError(reason=str(exc))
return web.Response()
async def handler(request: web.Request) -> NoReturn:
# Since `resolve_job` excepts any Exception, `assert` will be caught there
name = request.query.get("name")
if name != job_name:
pytest.fail(f"received: {name}")
owner = request.query.get("owner")
if owner != "user":
pytest.fail(f"received: {owner}")
raise web.HTTPError()
async def delete_collection_endpoint(request: Request):
origin = request.headers.get("Origin", "")
data = await request.json()
h = {"Access-Control-Allow-Origin": origin}
collection = data.get("collection", None)
if collection is None:
return web.HTTPBadRequest(headers=h, reason="Missing required field: 'collection'")
folder = Path(CONFIG.working_directory).absolute() / "collections" / collection
try:
shutil.rmtree(folder)
except Exception as e:
return web.HTTPError(reason=f"Error when attempting delete: {e}", headers=h)
return web.HTTPOk(headers=h)
async def post(self) -> Union[web.json_response, web.HTTPException]:
request_data = await self.request.json()
if await self.is_user_exist(request_data):
raise web.HTTPConflict(text="User already exist")
data = await self.prepare_db_request(request_data)
result = await self.request.app['db'].users.insert_one(data)
if result:
return web.Response(text="User create successfully", status=200)
raise web.HTTPError(text="Unexpected error")
async def post_search_settings(request):
db = request.app['db']
data = await request.json()
try:
validated = search_settings_schema.check(data)
except DataError as err:
return web.HTTPError(reason=err.error)
await add_or_update_setting(db, validated)
updated_data = await get_setting(db)
return web.json_response(data=updated_data,
content_type='application/json')
async def handler(request: web.Request) -> NoReturn:
# Since `resolve_job` excepts any Exception, `assert` will be caught there
name = request.query.get("name")
if name != job_name:
pytest.fail(f"received: {name}")
owner = request.query.get("owner")
if owner != job_owner:
pytest.fail(f"received: {owner}")
reverse = request.query.get("reverse")
if reverse != "1":
pytest.fail(f"received: reverse={reverse}")
limit = request.query.get("limit")
if limit != "1":
pytest.fail(f"received: limit={limit}")
raise web.HTTPError()
async def invite_room(whom_to_send, whom_to_room, redis, user):
if not whom_to_send or not whom_to_room:
return web.HTTPError()
user_ver_slug = await create_slug(user)
whom_to_room_ver_slug = await create_slug(whom_to_room)
lst_invite = await redis.hgetall(whom_to_send, encoding='utf-8')
if lst_invite == {}:
user = user + '.---.' + str(user_ver_slug)
whom_to_room = whom_to_room + '.---.' + str(whom_to_room_ver_slug)
await redis.hmset(whom_to_send, user, whom_to_room)
else:
user = user + '.---.' + str(
user_ver_slug) + f'___-%-_{str(randint(10, 99))}'
whom_to_room = whom_to_room + '.---.' + str(whom_to_room_ver_slug)
await redis.hmset(whom_to_send, user, whom_to_room)
async def middleware(request, handler):
perf.views += 1
resp = await handler(request)
headers = request.headers
if 'user-agent' in headers:
print(f'{request.path} has been viewed by', headers['user-agent'])
else:
print(f'{request.path} has been viewed by an unknown user', headers)
return web.HTTPError('Error: No UA found')
# if ''
if resp.content_type == 'text/html':
try:
resp.text = resp.text.replace('[[PATH]]', request.path)
except AttributeError:
pass
return resp
async def get_state(self, request):
"""
Relay get value
"""
try:
relay = int(request.match_info['relay'])
relay_mapped = next((x for x in self.mapping if x['id'] == relay),
None)
if relay_mapped == None:
return web.HTTPError()
relay_value = self.gpio.get(relay_mapped['chip']).value(
relay_mapped['line'])
return web.json_response({
"state":
RelayController.relay_status(relay_mapped, relay_value)
})
except ValueError:
return web.HTTPNotFound(text="Relay not found")
async def _request(cls,
url,
method='GET',
params=None,
headers=None,
cookies=None,
encoding=None,
debug=False):
params = params or {}
method = method.lower()
headers = headers or cls.get_header()
cookies = cookies or cls.cookies
encoding = encoding or ('utf-8', 'backslashreplace')
if method not in ('get', 'post'):
raise web.HTTPError('Method must be of GET or POST')
async with aiohttp.ClientSession(cookies=cookies) as session:
request_call = getattr(session, method)
async with request_call(url,
params=params,
headers=headers,
timeout=30) as res:
if debug:
print('HTTP {} {} {} with params {} and headers {}'.format(
method, res.status, url, params, headers))
if res.status == 200:
ctype = res.headers.get('Content-type', '').lower()
if 'json' in ctype or url.endswith('json'):
data = await res.json()
else:
data = await res.text(*encoding)
return data
elif res.status == 404:
raise web.HTTPNotFound()
else:
raise aiohttp.errors.HttpProcessingError(
code=res.status,
message=res.reason,
headers=res.headers)
async def apply(request: web.BaseRequest):
context = request.app["request_context"]
params = await request.json()
outbound_handler = request.app["outbound_message_router"]
connection_id = params["connection_id"]
payload = params["payload"]
service_id = params["service"]["service_id"]
consent_schema = params["service"]["consent_schema"]
service_schema = params["service"]["service_schema"]
label = params["service"]["label"]
try:
connection: ConnectionRecord = await ConnectionRecord.retrieve_by_id(
context, connection_id
)
except StorageNotFoundError:
raise web.HTTPNotFound(reason="Connection not found")
#
# NOTE(KKrzosa): Send a credential offer for consent to the other agent
# TODO(KKrzosa): Cache the credential definition
#
ledger: BaseLedger = await context.inject(BaseLedger)
issuer: BaseIssuer = await context.inject(BaseIssuer)
try:
# NOTE: Register Schema on LEDGER
async with ledger:
schema_id, schema_definition = await shield(
ledger.create_and_send_schema(
issuer,
"consent_schema",
"1.0",
[
"oca_schema_dri",
"oca_schema_namespace",
"data_dri",
"service_consent_match_id",
],
)
)
LOGGER.info("OK consent schema saved on ledger! %s", schema_id)
# TODO: Error here with unpacking it returns a dict now
# NOTE: Register Credential DEFINITION on LEDGER
async with ledger:
credential_definition_id, credential_definition, novel = await shield(
ledger.create_and_send_credential_definition(
issuer,
schema_id,
signature_type=None,
tag="consent_schema",
)
)
LOGGER.info(
"OK consent_schema CREDENTIAL DEFINITION saved on ledger! %s",
credential_definition_id,
)
# NOTE: Create credential OFFER
(
credential_exchange_record,
credential_offer_message,
service_consent_match_id,
) = await create_consent_credential_offer(
context=context,
cred_def_id=credential_definition_id,
connection_id=connection_id,
consent_schema=consent_schema,
auto_issue=True,
auto_remove=False,
)
except (LedgerError, IssuerError, BadLedgerRequestError) as err:
LOGGER.error(
"credential offer creation error! %s",
err,
)
raise web.HTTPError(reason="Ledger error, credential offer creation error")
if connection.is_ready:
await outbound_handler(credential_offer_message, connection_id=connection_id)
payload_dri = await save_string(context, payload)
record = ServiceIssueRecord(
connection_id=connection_id,
state=ServiceIssueRecord.ISSUE_WAITING_FOR_RESPONSE,
author=ServiceIssueRecord.AUTHOR_SELF,
service_id=service_id,
label=label,
consent_schema=consent_schema,
service_schema=service_schema,
payload_dri=payload_dri,
credential_definition_id=credential_exchange_record.credential_definition_id,
service_consent_match_id=service_consent_match_id,
)
data_dri = await record.save(context)
request = Application(
service_id=record.service_id,
exchange_id=record.exchange_id,
credential_definition_id=credential_exchange_record.credential_definition_id,
data_dri=data_dri,
service_consent_match_id=service_consent_match_id,
)
await outbound_handler(request, connection_id=connection_id)
return web.json_response(request.serialize())
raise web.HTTPBadGateway
async def process_application(request: web.BaseRequest):
outbound_handler = request.app["outbound_message_router"]
context = request.app["request_context"]
params = await request.json()
REJECTED = ServiceIssueRecord.ISSUE_REJECTED
LEDGER_ERROR = ServiceIssueRecord.ISSUE_SERVICE_LEDGER_ERROR
ACCEPTED = ServiceIssueRecord.ISSUE_ACCEPTED
try:
issue: ServiceIssueRecord = await ServiceIssueRecord.retrieve_by_id(
context, params["issue_id"]
)
service: ServiceRecord = await ServiceRecord.retrieve_by_id(
context, issue.service_id
)
except StorageNotFoundError:
raise web.HTTPNotFound
confirmer = StatusConfirmer(
outbound_handler, issue.connection_id, issue.exchange_id
)
#
# NOTE(KKrzosa): Validate the state of the issue and
# check if credential is correct
# TODO(KKrzosa): inform about invalid credential
#
if params["decision"] == "reject" or issue.state == REJECTED:
issue.state = REJECTED
await issue.save(context, reason="Issue reject saved")
await confirmer.send_confirmation(issue.state)
return web.json_response(issue.serialize())
service_namespace = service.consent_schema["oca_schema_namespace"]
service_dri = service.consent_schema["oca_schema_dri"]
service_data_dri = service.consent_schema["data_dri"]
credentials: BaseRecord = await THCFCredential.query(context)
# TODO: Optimize
found_credential = None
for cred in credentials:
if (
cred.credentialSubject["data_dri"] == service_data_dri
and cred.credentialSubject["oca_schema_namespace"] == service_namespace
and cred.credentialSubject["oca_schema_dri"] == service_dri
and cred.credentialSubject["service_consent_match_id"]
== issue.service_consent_match_id
):
found_credential = cred
break
if found_credential == None:
raise web.HTTPNotFound(reason="Credential for consent not found")
#
# NOTE(KKrzosa): Create a schema and credential def but only if they dont exist
# and based on those issue a credential
#
service_manager: ServiceManager = await create_service_manager(context, service)
try:
await service_manager.create_schema()
await service_manager.create_credential_definition()
(
credential_exchange_record,
credential_offer_message,
) = await service_manager.create_credential_offer(
connection_id=issue.connection_id,
preview_spec={
"@type": "did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/issue-credential/1.0/credential-preview",
"attributes": [
{
"name": "oca_schema_dri",
"mime-type": "application/json",
"value": service.service_schema["oca_schema_dri"],
},
{
"name": "data_dri",
"mime-type": "application/json",
"value": issue.payload_dri,
},
{
"name": "oca_schema_namespace",
"mime-type": "application/json",
"value": service.service_schema["oca_schema_namespace"],
},
{
"name": "service_consent_match_id",
"mime-type": "application/json",
"value": issue.service_consent_match_id,
},
],
},
auto_issue=True,
auto_remove=False,
)
except (LedgerError, IssuerError, BadLedgerRequestError) as err:
LOGGER.error(
"credential offer creation error! %s",
err,
)
issue.state = LEDGER_ERROR
raise web.HTTPError(reason="Ledger error, credential offer creation error")
issue.state = ACCEPTED
await issue.save(context, reason="Accepted service issue, credential offer created")
await confirmer.send_confirmation(issue.state)
await outbound_handler(credential_offer_message, connection_id=issue.connection_id)
return web.json_response(
{
"issue": issue.serialize(),
"credential_exchange_record": credential_exchange_record.serialize(),
}
)
