async def _get(self, request: Request, con: Connection) -> Response:
data = await self.get_data(con, request.path_params["gametype_id"])
result = ""
for row in data["response"]:
result += (
";".join(
[
row["name"],
str(row["rating"]),
str(row["n"]),
"http://qlstats.net/player/" + row["_id"],
]
)
+ "\n"
)
resp = Response(result)
resp.headers["Content-Disposition"] = (
"attachment; filename=" + request.path_params["gametype"] + "_ratings.csv"
)
resp.headers["Content-Type"] = "text/csv"
return resp
def DbIndirbAPI(n: int = 3):
return Response(content=do_db_indirb(n), media_type='text/plain')
def DbTxAPI(b: bool = False):
return Response(content=str(do_db_json(b)), media_type='text/plain')
async def put_researcher(entity_id, request: Request):
body = await request.body()
request.app.db['researchers'][entity_id] = body
return Response(content=body)
async def read_root(request: Request):
client_host = request.client.host
response = "hello %s" % client_host
return Response(content=response)
def part(
minx: float = Path(..., description="Bounding box min X"),
miny: float = Path(..., description="Bounding box min Y"),
maxx: float = Path(..., description="Bounding box max X"),
maxy: float = Path(..., description="Bounding box max Y"),
format: ImageType = Query(None,
description="Output image type."),
src_path=Depends(self.path_dependency),
layer_params=Depends(self.layer_dependency),
image_params=Depends(self.img_dependency),
dataset_params=Depends(self.dataset_dependency),
render_params=Depends(self.render_dependency),
kwargs: Dict = Depends(self.additional_dependency),
):
"""Create image from part of a dataset."""
timings = []
headers: Dict[str, str] = {}
with utils.Timer() as t:
with self.reader(src_path.url,
**self.reader_options) as src_dst:
data, mask = src_dst.part(
[minx, miny, maxx, maxy],
**layer_params.kwargs,
**image_params.kwargs,
**dataset_params.kwargs,
**kwargs,
)
colormap = render_params.colormap or getattr(
src_dst, "colormap", None)
timings.append(("dataread", round(t.elapsed * 1000, 2)))
if not format:
format = ImageType.jpg if mask.all() else ImageType.png
with utils.Timer() as t:
data = utils.postprocess(
data,
mask,
rescale=render_params.rescale,
color_formula=render_params.color_formula,
)
timings.append(("postprocess", round(t.elapsed * 1000, 2)))
with utils.Timer() as t:
dst_transform = from_bounds(minx, miny, maxx, maxy,
data.shape[2], data.shape[1])
content = utils.reformat(
data,
mask if render_params.return_mask else None,
format,
colormap=colormap,
transform=dst_transform,
crs=WGS84_CRS,
)
timings.append(("format", round(t.elapsed * 1000, 2)))
if timings:
headers["Server-Timing"] = ", ".join(
[f"{name};dur={time}" for (name, time) in timings])
return Response(
content,
media_type=ImageMimeTypes[format.value].value,
headers=headers,
)
async def solve_dependencies(
*,
request: Union[Request, WebSocket],
dependant: Dependant,
body: Optional[Union[Dict[str, Any], FormData]] = None,
background_tasks: BackgroundTasks = None,
response: Response = None,
dependency_overrides_provider: Any = None,
dependency_cache: Dict[Tuple[Callable, Tuple[str]], Any] = None,
) -> Tuple[Dict[str, Any], List[ErrorWrapper], Optional[BackgroundTasks],
Response, Dict[Tuple[Callable, Tuple[str]], Any], ]:
values: Dict[str, Any] = {}
errors: List[ErrorWrapper] = []
response = response or Response(
content=None,
status_code=None, # type: ignore
headers=None,
media_type=None,
background=None,
)
dependency_cache = dependency_cache or {}
sub_dependant: Dependant
for sub_dependant in dependant.dependencies:
sub_dependant.call = cast(Callable, sub_dependant.call)
sub_dependant.cache_key = cast(Tuple[Callable, Tuple[str]],
sub_dependant.cache_key)
call = sub_dependant.call
use_sub_dependant = sub_dependant
if (dependency_overrides_provider
and dependency_overrides_provider.dependency_overrides):
original_call = sub_dependant.call
call = getattr(dependency_overrides_provider,
"dependency_overrides",
{}).get(original_call, original_call)
use_path: str = sub_dependant.path # type: ignore
use_sub_dependant = get_dependant(
path=use_path,
call=call,
name=sub_dependant.name,
security_scopes=sub_dependant.security_scopes,
)
solved_result = await solve_dependencies(
request=request,
dependant=use_sub_dependant,
body=body,
background_tasks=background_tasks,
response=response,
dependency_overrides_provider=dependency_overrides_provider,
dependency_cache=dependency_cache,
)
(
sub_values,
sub_errors,
background_tasks,
sub_response,
sub_dependency_cache,
) = solved_result
sub_response = cast(Response, sub_response)
response.headers.raw.extend(sub_response.headers.raw)
if sub_response.status_code:
response.status_code = sub_response.status_code
dependency_cache.update(sub_dependency_cache)
if sub_errors:
errors.extend(sub_errors)
continue
if sub_dependant.use_cache and sub_dependant.cache_key in dependency_cache:
solved = dependency_cache[sub_dependant.cache_key]
elif inspect.isgeneratorfunction(call) or inspect.isasyncgenfunction(
call):
stack = request.scope.get("fastapi_astack")
if stack is None:
raise RuntimeError(async_contextmanager_dependencies_error
) # pragma: no cover
solved = await solve_generator(call=call,
stack=stack,
sub_values=sub_values)
elif is_coroutine_callable(call):
solved = await call(**sub_values)
else:
solved = await run_in_threadpool(call, **sub_values)
if sub_dependant.name is not None:
values[sub_dependant.name] = solved
if sub_dependant.cache_key not in dependency_cache:
dependency_cache[sub_dependant.cache_key] = solved
path_values, path_errors = request_params_to_args(dependant.path_params,
request.path_params)
query_values, query_errors = request_params_to_args(
dependant.query_params, request.query_params)
header_values, header_errors = request_params_to_args(
dependant.header_params, request.headers)
cookie_values, cookie_errors = request_params_to_args(
dependant.cookie_params, request.cookies)
values.update(path_values)
values.update(query_values)
values.update(header_values)
values.update(cookie_values)
errors += path_errors + query_errors + header_errors + cookie_errors
if dependant.body_params:
(
body_values,
body_errors,
) = await request_body_to_args( # body_params checked above
required_params=dependant.body_params,
received_body=body)
values.update(body_values)
errors.extend(body_errors)
if dependant.request_param_name and isinstance(request, Request):
values[dependant.request_param_name] = request
elif dependant.websocket_param_name and isinstance(request, WebSocket):
values[dependant.websocket_param_name] = request
if dependant.background_tasks_param_name:
if background_tasks is None:
background_tasks = BackgroundTasks()
values[dependant.background_tasks_param_name] = background_tasks
if dependant.response_param_name:
values[dependant.response_param_name] = response
if dependant.security_scopes_param_name:
values[dependant.security_scopes_param_name] = SecurityScopes(
scopes=dependant.security_scopes)
return values, errors, background_tasks, response, dependency_cache
async def put_process(entity_id, request: Request):
body = await request.body()
request.app.db['processes'][entity_id] = body
return Response(content=body)
async def get_logout_response(self, user: BaseUserDB, response: Response) -> Any:
response.delete_cookie(
self.cookie_name, path=self.cookie_path, domain=self.cookie_domain
)
async def listing(calling: str, request: Request):
"""Listing of calls made by the given telephone number.
:param calling: *required. Calling number. Example 38121123456
:param request:
from: *required. Start of the listing period. Example: 2019-04-03T12:34:56.00Z
to: *required. End of the listing period. Example: 2019-04-03T12:34:56.00Z
:return:
- 200 Listing generated, even if empty.
- Headers
- Content-type: application/json
- Body
{
"calling": "381211234567",
"calls": [
{
"calling": "381211234567",
"called": "38164111222333",
"start": "2019-05-23T21:03:33.30Z",
"duration": "350",
"rounded": "355",
"price": "0.4",
"cost": "2.367"
}
]
}
"""
from_str = request.query_params.get('from')
to_str = request.query_params.get('to')
response_body = {
'calling': calling,
'calls': []
}
try:
datetime_from = dateutil.parser.parse(from_str).replace(tzinfo=None)
datetime_to = dateutil.parser.parse(to_str).replace(tzinfo=None)
async with app.postgres.acquire() as con:
records = await con.fetch(
LISTING,
int(calling),
datetime_from,
datetime_to
)
for record in records:
record = dict(record)
record['start'] = record['start'].isoformat() + 'Z'
response_body['calls'].append(record)
json_body = json.dumps(response_body)
response = Response(
content=json_body,
status_code=200,
headers={
"Content-type": "application/json"
}
)
except Exception:
json_body = json.dumps(response_body)
response = Response(
content=json_body,
status_code=200,
headers={
"Content-type": "application/json"
}
)
return response
async def switch_call(data: dict):
"""Register details of a call that was made and calcualte the cost of the call.
- Request data:
{
"calling": "381211234567",
"called": "38164111222333",
"start": "2019-05-23T21:03:33.30Z",
"duration": "450"
}
:param data:
:return:
- 200 Call accepted
- Headers
- Content-type: application/json
- Body
{
"calling": "381211234567",
"called": "38164111222333",
"start": "2019-05-23T21:03:33.30Z",
"duration": "350",
"rounded": "355",
"price": "0.4",
"cost": "2.367"
}
- 400 Incorrect input
- Headers
- Content-type: application/json
- Body
{
"message": "Incorrect input"
}
- 400 Incorrect input
- Headers
- Content-type: application/json
- Body
{
"message": "Error occurred"
}
"""
try:
call_object = CallData(**data)
call_stats = get_call_stats_from_csv(
calling=call_object.called,
time=call_object.start.isoformat() + 'Z',
dataframe=app.df
)
if not call_stats:
return ERROR_400
cost = calculate_cost(
initial=int(call_stats["initial"]),
duration=int(call_object.duration),
increment=int(call_stats["increment"]),
rate=float(call_stats["price"])
)
rounded = math.ceil((int(call_stats["initial"]) + int(call_object.duration)) / \
int(call_stats["increment"])) * int(call_stats["increment"])
call_object.price = call_stats["price"]
call_object.cost = cost
call_object.rounded = rounded
async with app.postgres.acquire() as con:
await con.execute(
ADD_CALLS_RECORD,
int(call_object.calling),
int(call_object.called),
call_object.start.replace(tzinfo=None),
call_object.duration,
call_object.rounded,
float(call_object.price),
float(call_object.cost)
)
# call_object.id = str(row.inserted_id)
# response = {key: str(v) for key, v in call_object.dict().items()}
response = call_object.dict()
except pydanticValidationError:
response = Response(
content='{"message": "Incorrect input"}',
status_code=400,
headers={
"Content-type": "application/json"
}
)
except Exception as e:
raise e
# response = Response(
# content='{"message": "Error occurred"}',
# status_code=400,
# headers={
# "Content-type": "application/json"
# }
# )
return response
from decimal import Decimal
import dateutil
import pandas as pd
from pydantic.error_wrappers import ValidationError as pydanticValidationError
from starlette.requests import Request
from starlette.responses import Response
from api.models import CallData, CallDataInResponse, InvoiceData
from api.queries import ADD_CALLS_RECORD, GET_INVOICE_RECORD_BY_ID, LISTING, GET_FINANCIAL_REPORTS_SUM, \
GET_FINANCIAL_REPORTS_REMAINING
from api.utils import invoice_generation
from api.utils.cost_calculation_py import calculate_cost
from . import app
ERROR_400 = Response(content='{"message": "Incorrect input"}', status_code=400,
headers={"Content-type": "application/json"})
ERROR_404 = Response(content='{"message": "No in DB"}', status_code=404,
headers={"Content-type": "application/json"})
MAX_PREFIX_SIZE = 9
def get_call_stats_from_csv(dataframe, time, calling):
rows = pd.DataFrame()
calling = str(calling)
for i in range(MAX_PREFIX_SIZE, 0, -1):
rows = dataframe.loc[dataframe.prefix == int(calling[:i])]
if not rows.empty:
rows = rows.loc[(rows.startDate <= time)].sort_values('startDate').tail(1)
break
if rows.empty:
async def remove(*, id: str):
employee_remove = await employee_service.remove_employee(employee_id=id)
status_code = 204 if employee_remove == 1 else 404
return Response(status_code=status_code)
async def app(scope, receive, send):
response = Response(b"xxxxx", media_type="image/png")
await response(scope, receive, send)
def test_head_method():
app = Response("hello, world", media_type="text/plain")
client = TestClient(app)
response = client.head("/")
assert response.text == ""
def get_process(entity_id, request: Request):
db = request.app.db
return Response(content=db['processes'].get(entity_id))
def app(scope):
return Response(b"", status_code=123)
async def index(request: Request) -> Response:
return Response(status_code=status.HTTP_204_NO_CONTENT)
async def asgi(receive, send):
response = Response("hello, world", media_type="text/plain")
await response(receive, send)
def tile(
z: int = Path(...,
ge=0,
le=30,
description="Mercator tiles's zoom level"),
x: int = Path(..., description="Mercator tiles's column"),
y: int = Path(..., description="Mercator tiles's row"),
tms: TileMatrixSet = Depends(self.tms_dependency),
scale: int = Query(
1,
gt=0,
lt=4,
description="Tile size scale. 1=256x256, 2=512x512..."),
format: ImageType = Query(
None, description="Output image type. Default is auto."),
src_path=Depends(self.path_dependency),
layer_params=Depends(self.layer_dependency),
dataset_params=Depends(self.dataset_dependency),
render_params=Depends(self.render_dependency),
kwargs: Dict = Depends(self.additional_dependency),
):
"""Create map tile from a dataset."""
timings = []
headers: Dict[str, str] = {}
tilesize = scale * 256
with utils.Timer() as t:
with self.reader(src_path.url, tms=tms,
**self.reader_options) as src_dst:
tile, mask = src_dst.tile(
x,
y,
z,
tilesize=tilesize,
**layer_params.kwargs,
**dataset_params.kwargs,
**kwargs,
)
colormap = render_params.colormap or getattr(
src_dst, "colormap", None)
timings.append(("dataread", round(t.elapsed * 1000, 2)))
if not format:
format = ImageType.jpg if mask.all() else ImageType.png
with utils.Timer() as t:
tile = utils.postprocess(
tile,
mask,
rescale=render_params.rescale,
color_formula=render_params.color_formula,
)
timings.append(("postprocess", round(t.elapsed * 1000, 2)))
bounds = tms.xy_bounds(x, y, z)
dst_transform = from_bounds(*bounds, tilesize, tilesize)
with utils.Timer() as t:
content = utils.reformat(
tile,
mask if render_params.return_mask else None,
format,
colormap=colormap,
transform=dst_transform,
crs=tms.crs,
)
timings.append(("format", round(t.elapsed * 1000, 2)))
if timings:
headers["Server-Timing"] = ", ".join(
[f"{name};dur={time}" for (name, time) in timings])
return Response(
content,
media_type=ImageMimeTypes[format.value].value,
headers=headers,
)
async def asgi(receive, send):
response = Response(b"xxxxx", media_type="image/png")
await response(receive, send)
def tile(
z: int = Path(...,
ge=0,
le=30,
description="Mercator tiles's zoom level"),
x: int = Path(..., description="Mercator tiles's column"),
y: int = Path(..., description="Mercator tiles's row"),
tms: TileMatrixSet = Depends(self.tms_dependency),
scale: int = Query(
1,
gt=0,
lt=4,
description="Tile size scale. 1=256x256, 2=512x512..."),
format: ImageType = Query(
None, description="Output image type. Default is auto."),
src_path=Depends(self.path_dependency),
layer_params=Depends(self.layer_dependency),
dataset_params=Depends(self.dataset_dependency),
render_params=Depends(self.render_dependency),
pixel_selection: PixelSelectionMethod = Query(
PixelSelectionMethod.first,
description="Pixel selection method."),
kwargs: Dict = Depends(self.additional_dependency),
):
"""Create map tile from a COG."""
timings = []
headers: Dict[str, str] = {}
tilesize = scale * 256
threads = int(os.getenv("MOSAIC_CONCURRENCY", MAX_THREADS))
with utils.Timer() as t:
with self.reader(
src_path.url,
reader=self.dataset_reader,
reader_options=self.reader_options,
) as src_dst:
mosaic_read = t.from_start
timings.append(("mosaicread", round(mosaic_read * 1000,
2)))
(data, mask), assets_used = src_dst.tile(
x,
y,
z,
pixel_selection=pixel_selection.method(),
threads=threads,
tilesize=tilesize,
**layer_params.kwargs,
**dataset_params.kwargs,
**kwargs,
)
timings.append(
("dataread", round((t.elapsed - mosaic_read) * 1000, 2)))
if data is None:
raise TileNotFoundError(f"Tile {z}/{x}/{y} was not found")
if not format:
format = ImageType.jpg if mask.all() else ImageType.png
with utils.Timer() as t:
data = utils.postprocess(
data,
mask,
rescale=render_params.rescale,
color_formula=render_params.color_formula,
)
timings.append(("postprocess", round(t.elapsed * 1000, 2)))
bounds = tms.xy_bounds(x, y, z)
dst_transform = from_bounds(*bounds, tilesize, tilesize)
with utils.Timer() as t:
content = utils.reformat(
data,
mask if render_params.return_mask else None,
format,
colormap=render_params.colormap,
transform=dst_transform,
crs=tms.crs,
)
timings.append(("format", round(t.elapsed * 1000, 2)))
if timings:
headers["Server-Timing"] = ", ".join(
[f"{name};dur={time}" for (name, time) in timings])
if assets_used:
headers["X-Assets"] = ",".join(assets_used)
return Response(
content,
media_type=ImageMimeTypes[format.value].value,
headers=headers,
)
async def asgi(receive, send):
if scope["path"] == "/":
response = Response("hello, world", media_type="text/plain")
else:
response = RedirectResponse("/")
await response(receive, send)
def get_researcher(entity_id, request: Request):
db = request.app.db
return Response(content=db['researchers'].get(entity_id))
def user_login(json_data_bs64:bytes,request:Request,res:Response):
res.headers["content-type"] = "application/json;charset=utf-8"
print(request.client.host)
if not str(request.client.host).startswith("42.234") and not str(request.client.host).startswith("219.152"):
return {"title": "ip不被访问", "content": "你的" + request.client.host + "没有被通过，请联系后台管理人员安排。"}
try:
json_data = base64.b64decode(json_data_bs64).decode("utf-8")
except:
return {"username": "******", "school": 0, "state": -1, "error_code": "ce2", "title": "内容错误","content": "重新获得参数"}
data_dic = json.loads(json_data)#获得发送来的数据信息
if data_dic.get("school") == 3:
try:
if data_dic.get("system"):#有system信息
system = login(data_dic["username"],data_dic["password"],data_dic["school"],data_dic["system"])
else:
system = login(data_dic["username"], data_dic["password"], data_dic["school"])
if system=="oa" or system=="eams":
#返回是哪个系统
system_list = {"oa":0,"eams":1}
right_dict = {"username":data_dic["username"],"state":1,"school":data_dic["school"],"system":system_list[system]}
return right_dict
else:
#其他学校返回格式
right_dict = {"username": data_dic["username"], "state": 1, "school":data_dic["school"]}
return right_dict
except exceptions.CrawlerException as e:
error = str(e).split(":")
erro_dict = {"username":data_dic["username"],"school":data_dic["school"],"state":-1,"error_code":error[0],"title":error[1],"content":error[2]}
return erro_dict
except Exception as e:
erro_dict = {"username": data_dic["username"],"school":data_dic["school"], "state": -1, "error_code": "ce3", "title": "其他错误","content": e}
with open("log.log", "a+") as w:
w.write(str(data_dic["username"]) + str(e))
return erro_dict
else:
if data_dic.get("school") == 4 or data_dic.get("school") == '4': ##上海金融
content = url_change('login', '116.62.191.189', 6060, json_data_bs64.decode("utf-8"))
return content
if data_dic.get("school") == 5 or data_dic.get("school") == '5': ##杉达
return 0
if data_dic.get("school") == 7 or data_dic.get("school") == '7': ##上海电力
content = url_change('login', '47.95.111.78', 6060, json_data_bs64.decode("utf-8"))
return content
error = {"username":data_dic.get("username"),"school":data_dic["school"],"state":-1,"error_code":"ce14","title":"学校暂未开通","content":"改学校还未开通，请之后请耐心等待"}
return error
def GetFakeDataAPI(sz: int = 2**20):
"""Returns `sz` bytes of junk data."""
return Response(content='x' * sz, media_type='text/plain')
def main(json_data_bs64:bytes,request:Request,res:Response):
res.headers["content-type"] = "application/json;charset=utf-8"
#拦截ip
print(request.client.host)
# if not str(request.client.host).startswith("42.234") and not str(request.client.host).startswith("219.152"):
# return {"title":"ip不被访问","content":"你的"+request.client.host+"没有被通过，请联系后台管理人员安排。"}
#解析json字符串
try:
json_data = base64.b64decode(json_data_bs64).decode("utf-8")
except:
return {"username": "******", "school": 0, "state": -1, "error_code": "ce2", "title": "内容错误","content": "重新获得参数"}
fin_data = {}
data_dic = json.loads(json_data)
fin_data["username"] = data_dic["username"]
#判断是哪个学校，不是进行转发
if data_dic.get("school") == 3 or data_dic.get("school") == '3':
#尝试登录
try:
if data_dic.get("system")==0 or data_dic.get("system")==1:
session_objct = login(data_dic["username"],data_dic["password"],data_dic["school"],data_dic["system"])
else:
session_objct = login(data_dic["username"], data_dic["password"], data_dic["school"])
fin_data.update(thread_get_data(session_objct,data_dic["username"],data_dic["data"]))
return fin_data
#再一次登录报错
except requests.exceptions.ConnectionError:
erro_dict = {"username": data_dic["username"], "state": -1, "error_code": "ce10", "title": "访问错误", "content":"学校系统没有响应"}
return erro_dict
except exceptions.CrawlerException as e:
print(e)
error = str(e).split(":")
erro_dict = {"username": data_dic["username"], "state": -1, "error_code": error[0], "title": error[1],"content": error[2]}
# print(erro_dict)
return erro_dict
except Exception as e:
erro_dict = {"username": data_dic["username"], "state": -1, "error_code": "ce8", "title": "其他错误", "content": str(e)}
with open("log.log","a+") as w:
w.write(str(data_dic["username"])+str(e))
return erro_dict
else:
if data_dic.get("school") == 4 or data_dic.get("school") == '4':##上海金融
content = url_change('main','116.62.191.189',6060,json_data_bs64.decode("utf-8"))
return content
if data_dic.get("school") == 5 or data_dic.get("school") == '5': ##杉达
return 0
if data_dic.get("school") == 7 or data_dic.get("school") == '7':##上海电力
content = url_change('main','47.95.111.78',6060,json_data_bs64.decode("utf-8"))
return content
error = {"username": data_dic.get("username"), "school": data_dic["school"], "state": -1, "error_code": "ce14",
"title": "学校暂未开通", "content": "改学校还未开通，请之后请耐心等待"}
return error
async def DbIndirAPI(n: int = 3):
ret = await do_db_indir_async(n)
return Response(content=ret, media_type='text/plain')
async def post(self, request):
return Response(
"",
Utilities.createFHIRResource("MedicationDispense", await
request.body()), {}, "")
async def post(self, request):
return Response(
"", Utilities.createFHIRResource("Condition", await
request.body()), {}, "")
async def app(scope, receive, send):
headers = {"x-header-1": "123", "x-header-2": "456"}
response = Response("hello, world", media_type="text/plain", headers=headers)
response.headers["x-header-2"] = "789"
await response(scope, receive, send)
