async def regCode(username: str = Query(...), session: str = Header(...)):
return utils.needAuth(username, session, lambda: utils.getRegCode())
def get_header(*, someheader: str = Header(...)):
return someheader
async def read_items(*, strange_header: str = Header(None, convert_underscores=False)):
return {"strange_header": strange_header}
def refresh_user(self,
rf_token: str = Header(None,
min_length=50,
max_length=50,
convert_underscores=False)):
return self.user_service.refresh_user(rf_token)
async def get_token_header(x_token: str = Header(...)):
if x_token != "fake-super-secret-token":
raise HTTPException(status_code=400, detail="X-Token header invalid")
def get_header(head_name=Header(None)):
return head_name
async def read_main(item_id: str, x_token: str = Header()):
if x_token != fake_secret_token:
raise HTTPException(status_code=400, detail="Invalid X-Token header")
if item_id not in fake_db:
raise HTTPException(status_code=404, detail="Item not found")
return fake_db[item_id]
async def read_items2(*, user_agent: str = Header(None)):
return {"User-Agent": user_agent}
async def read_items2(x_token: List[str] = Header(None)):
return {"X-Token values": x_token}
async def read_items(*, device: str = Header(..., alias="X-Liftit-Device")):
return {"Device": device}
async def get_current_user(
x_pomerium_jwt_assertion: Optional[str] = Header(None)):
try:
return UserInfo.get_current(x_pomerium_jwt_assertion)
except Exception as err:
logger.error(f"User info could not be retrieved: {str(err)}")
async def video_getinfo(
username: str = Query(...),
hashv: str = Query(...),
session: str = Header(...),
):
return utils.needAuth(username, session, lambda: video.getinfo(hashv))
async def video_add(username: str = Query(...),
session: str = Header(...),
videos: List[model.video] = Body(..., embed=True)):
return utils.needAuth(username, session, lambda: video.add(videos))
async def user_auth(username: str = Query(...), session: str = Header(...)):
return user.auth(username, session)
def get_accept_type(accept: str = Header(None)) -> AcceptType:
return AcceptType[AcceptType(accept).name]
def weather_metric(request, vendor: str, auth_header: str = Header(...)):
return {"customRoute": ""}
async def agent_data(
uuid: UUID,
*,
certificate: str = Header(...),
compression: str = Header(...),
monitoring_data: UploadFile = File(...),
) -> Response:
host = Host(uuid)
if not host.registered:
logger.error(
"uuid=%s Host is not registered",
uuid,
)
raise HTTPException(
status_code=HTTP_403_FORBIDDEN,
detail="Host is not registered",
)
if host.host_type is not HostTypeEnum.PUSH:
logger.error(
"uuid=%s Host is not a push host",
uuid,
)
raise HTTPException(
status_code=HTTP_403_FORBIDDEN,
detail="Host is not a push host",
)
try:
decompressor = Decompressor(compression)
except ValueError:
logger.error(
"uuid=%s Unsupported compression algorithm: %s",
uuid,
compression,
)
raise HTTPException(
status_code=400,
detail=f"Unsupported compression algorithm: {compression}",
)
try:
decompressed_agent_data = decompressor(monitoring_data.file.read())
except DecompressionError as e:
logger.error(
"uuid=%s Decompression of agent data failed: %s",
uuid,
e,
)
raise HTTPException(
status_code=400,
detail="Decompression of agent data failed",
) from e
try:
_store_agent_data(
host.source_path,
decompressed_agent_data,
)
except FileNotFoundError:
# We only end up here in case someone re-configures the host at exactly the same time when
# data is being pushed. To avoid internal server errors, we still handle this case.
logger.error(
"uuid=%s Host is not registered or not configured as push host.",
uuid,
)
raise HTTPException(
status_code=403,
detail="Host is not registered or not configured as push host",
)
_move_ready_file(uuid)
logger.info(
"uuid=%s Agent data saved",
uuid,
)
return Response(status_code=HTTP_204_NO_CONTENT)
async def get_token_header(x_token: str = Header(...)):
if x_token != app_config.API_TOKEN:
raise HTTPException(status_code=400, detail="X-Token header invalid")
def get_header(head_name=Header(None, convert_underscores=False)):
return head_name
def me(response: Response, origin: Optional[str] = Header(None)):
response.headers["Access-Control-Allow-Origin"] = "http://127.0.0.1:8001"
response.set_cookie(key="hoge", value="fuga")
return profile
def user_logout(self,
ac_token: str = Header(None,
min_length=50,
max_length=50,
convert_underscores=False)):
return self.user_service.user_logout(ac_token)
async def verify_key(x_key: str = Header(...)):
if x_key != "fake-super-secret-key":
raise HTTPException(status_code=400, detail="X-Key Header invalid")
return x_key
def list_conversation(self,
ac_token: str = Header(None,
min_length=50,
max_length=50,
convert_underscores=False)):
return self.user_service.list_conversation(ac_token)
def get_user2(id, token=Header(None)):
return {"id": id, "token": token}
async def get_token_header(api_token: str = Header(...)):
if api_token not in settings.api_tokens:
raise HTTPException(status_code=400, detail="Api token header invalid")
async def root(q: str = "q", x_name: str = Header("test")):
return {"name": x_name, "q": q}
async def read_items(*, user_agent: str =Header(None)):
return {'uSER-Agent': user_agent}
def createEmployeeKey(emp: Employee, key: Optional[str] = Header(None)):
print("Received Key as Header: ", key)
empService.createEmployee(emp)
resData = "Employee key accepted and created successfully"
return Response(content=resData, status_code=200, media_type="plain/text")
async def read_items(x_token: List[str] = Header(None)):
return {'X-token values': x_token}
async def video_getsentencehash(username: str = Query(...),
session: str = Header(...)):
return utils.needAuth(username, session, lambda: video.getsentencehash())
