async def create_device(
device_params: CreateDeviceRequest,
auth_service: DevicesAuthService = Depends(get_service(DevicesAuthService)),
devices_service: DevicesService = Depends(get_service(DevicesService)),
) -> CreateDeviceResponse:
device = await devices_service.register_new_device(name=device_params.name)
token = auth_service.create_device_token(device)
return CreateDeviceResponse(token=token, name=device.name)
async def create_device_by_shared_key(
credentials: CreateDeviceBySharedKeyRequest,
auth_service: DevicesAuthService = Depends(get_service(DevicesAuthService)),
devices_service: DevicesService = Depends(get_service(DevicesService)),
) -> CreateDeviceBySharedKeyResponse:
is_shared_token_valid = auth_service.is_valid_shared_key(credentials.shared_key)
if not is_shared_token_valid:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail=strings.INVALID_SHARED_KEY,
)
device = await devices_service.register_new_device(name=credentials.name)
token = auth_service.create_device_token(device)
return CreateDeviceBySharedKeyResponse(token=token, name=device.name)
async def create_user(
new_user: UserInCreateRequest,
auth_users_service: AuthUsersService = Depends(
get_service(AuthUsersService)),
) -> UserInCreateResponse:
try:
user = await auth_users_service.register_new_user(
new_user.username, new_user.password, new_user.scopes)
except RuntimeError:
raise HTTPException(
status_code=HTTP_400_BAD_REQUEST,
detail=strings.USERNAME_TAKEN,
)
return UserInCreateResponse.parse_obj(user.dict())
async def login(
user: UserInLoginRequest = Depends(get_user_in_login),
users_service: AuthUsersService = Depends(get_service(AuthUsersService)),
) -> UserTokenInResponse:
try:
token_payload = await users_service.create_access_token(
username=user.username,
raw_password=user.password,
scopes=user.scopes)
except RuntimeError:
raise HTTPException(
status_code=HTTP_400_BAD_REQUEST,
detail=strings.INCORRECT_LOGIN_INPUT,
)
return UserTokenInResponse.parse_obj(token_payload)
async def _get_current_user(
security_scopes: SecurityScopes,
token: AccessToken = Depends(oauth2_schema),
users_service: AuthUsersService = Depends(get_service(AuthUsersService)),
) -> User:
try:
user = await users_service.find_user_by_token(token=token)
except RuntimeError:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=strings.MALFORMED_PAYLOAD,
)
if users_service.check_user_scopes(user.scopes, security_scopes):
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=strings.NOT_ENOUGH_PRIVILEGES,
)
return user
async def device_ws_endpoint( # noqa: WPS231
websocket: websockets.WebSocket,
token: str = Depends(get_bearer_token),
auth_service: DevicesAuthService = Depends(get_service(DevicesAuthService)),
broker_repo: DeviceBrokerRepo = Depends(get_repository(DeviceBrokerRepo)),
clients_manager: DevicesSocketManager = Depends(get_device_clients_manager),
socket_repo: DevicesSocketRepo = Depends(get_repository(DevicesSocketRepo)),
) -> None:
try:
device = await auth_service.get_device_from_token(token)
except RuntimeError as error:
logger.debug(f"device token decode error:{error}")
raise websockets.WebSocketDisconnect(code=status.WS_1008_POLICY_VIOLATION)
await clients_manager.connect(device.id, websocket)
await socket_repo.set_connected(device.id)
while True:
try: # noqa: WPS229
payload = await websocket.receive_text()
logger.debug(f"received response from device:{device.id}\n{payload}")
response = DeviceAgentResponse.parse_raw(payload)
except ValueError as validation_error:
logger.error(f"ws payload validation error {validation_error}")
except websockets.WebSocketDisconnect as disconnect_error:
logger.info(f"device:{device.id} disconnected, reason {disconnect_error}")
await clients_manager.disconnect(device.id)
await socket_repo.set_disconnected(device.id)
break
else:
if response.is_success:
await _publish_event(broker_repo, device, response)
else:
logger.error(
f"received error from device:{device.id}\n{response.error}"
)