def post(self, *args, **kwargs):
"""
Http method: POST
"""
data = request.data
pr_schema = PaymentRequestSchema()
try:
payment_request = pr_schema.load(data)
valid = payment_request.check_validity()
if not valid:
raise ValidationError(f'Timestamp is past due.')
processed_data, err = payment_request.process()
if err:
raise err
except ValidationError as e:
# print(e.messages)
return Response(
message='The request is invalid.',
status=status.HTTP_400_BAD_REQUEST,
error=True,
)
except Exception as unknown_err:
# raise
return Response(
message=str(unknown_err),
status=status.HTTP_500_INTERNAL_SERVER_ERROR,
error=True,
)
return Response(processed_data, status=status.HTTP_200_OK, message='Payment is processed.')
def post(self, request):
form = AddProjectsFrom(request.POST)
if form.is_valid():
name = form.cleaned_data.get('name')
desc = form.cleaned_data.get('desc')
Project.objects.create(name=name, desc=desc)
return Response(code='10000').json
else:
return Response(code='10001', msg=form.get_errors()).json
async def fetch(self) -> Response:
res_headers, res_history = {}, ()
res_status = 0
res_data, res_cookies = None, None
if self.request_config.get('DELAY', 0) > 0:
await asyncio.sleep(self.request_config['DELAY'])
try:
timeout = self.request_config.get('TIMEOUT', 10)
if self.load_js:
if not hasattr(self, "browser"):
self.browser = await pyppeteer.launch(
headless=True, args=['--no-sandbox'])
page = await self.browser.newPage()
res = await page.goto(self.url,
options={'timeout': int(timeout * 1000)})
res_data = await page.content()
res_cookies = await page.cookies()
res_headers = res.headers
res_history = None
res_status = res.status
else:
async with async_timeout.timeout(timeout):
async with self.current_request_func as resp:
res_status = resp.status
assert res_status in [200, 201]
if self.res_type == 'bytes':
res_data = await resp.read()
elif self.res_type == 'json':
res_data = await resp.json()
else:
content = await resp.read()
charset = chardet.detect(content)
res_data = content.decode(charset['encoding'])
res_cookies, res_headers, res_history = resp.cookies, resp.headers, resp.history
except Exception as e:
self.logger.error(f"<Error: {self.url} {res_status} {str(e)}>")
if self.retry_times > 0 and res_data is None:
retry_times = self.request_config.get('RETRIES',
3) - self.retry_times + 1
self.logger.info(
f'<Retry url: {self.url}>, Retry times: {retry_times}')
self.retry_times -= 1
return await self.fetch()
await self.close()
response = Response(url=self.url,
html=res_data,
metadata=self.metadata,
res_type=self.res_type,
cookies=res_cookies,
headers=res_headers,
history=res_history,
status=res_status)
return response
def post(self, request):
form = AddApiForm(request.POST)
if form.is_valid():
project_id = form.cleaned_data.get('project_id')
method = form.cleaned_data.get('method')
name = form.cleaned_data.get('name')
url = form.cleaned_data.get('url')
body = form.cleaned_data.get('body')
project = Project.objects.get(pk=project_id)
Api.objects.create(method=method,
name=name,
url=url,
body=body,
project=project)
return Response(code='10000').json
else:
return Response(code='10001', msg=form.get_errors()).json
def post(self, request):
form = LoginForm(request.POST)
if form.is_valid():
telephone = form.cleaned_data.get('telephone')
password = form.cleaned_data.get('password')
remember = form.cleaned_data.get('remember')
user = authenticate(request, username=telephone, password=password)
if user:
if user.is_active:
login(request, user)
if remember:
request.session.set_expiry(None)
else:
request.session.set_expiry(0)
return Response(code='10000').json
else:
return Response(code='10001', msg='账号被冻结').json
else:
return Response(code='10001', msg='手机或者密码错误').json
else:
return Response(code='10001', msg=form.get_errors()).json
async def connect(bot):
parser = argparse.ArgumentParser()
parser.add_argument("-p",
"--port",
help="Port of match generator to which to connect",
required=False,
default="8887")
parser.add_argument("-t",
"--token",
help="Identification token with which bot can connect",
required=False,
default="_")
parser.add_argument("-a",
"--host",
help="Hostname of match generator",
required=False,
default="localhost")
args = parser.parse_args()
async with websockets.connect("ws://{}:{}".format(args.host, args.port),
extra_headers={'token':
args.token}) as websocket:
try:
while True:
message = await websocket.recv()
data = json.loads(message)
response = Response(data['__uid'])
try:
if data['__type'] == 'INITIAL':
bot.setup(data)
elif data['__type'] == 'UPDATE':
bot.update(data, response)
response_json = json.dumps(response.__dict__)\
.replace("_Response__uid", "__uid")
await websocket.send(response_json)
except Exception as e:
print(e)
traceback.print_exc()
except websockets.ConnectionClosed:
print("Connection closed. Exiting...")
except Exception:
traceback.print_exc()
def post(self, request):
resp = Response()
get_listing(request, resp)
return HttpResponse(resp.get_response(),
content_type="application/json")
def get(self, request):
resp = Response()
register(request, resp)
return HttpResponse(resp.get_response(),
content_type="application/json")
def get(self, request):
resp = Response()
search_listings(request, resp)
return HttpResponse(resp.get_response(),
content_type="application/json")
def get(self, *args, **kwargs):
return Response('ProcessPayment', status=200)
def dispatch_request(request, path):
return Response(code='10000', data=path).json
def patch(self, *args, **kwargs):
return Response(self.message.format('PATCH'))
def put(self, *args, **kwargs):
return Response(self.message.format('PUT'))
def get(self, *args, **kwargs):
return Response(self.message.format('GET'))