def _do_get_order_list(
args: TbServiceGetOrderDetailsArgs, logger: BoundLogger
) -> Optional[List[dict]]:
dtk = DtkSyncApi(SConfig.DTKAppKey, SConfig.DTKAppSecret)
ret_list = dtk.tb_service_get_order_details(args)
logger.bind(ret_list=ret_list).info("get data")
return ret_list
def to_data(self: "GaoYongForm",
logger: BoundLogger) -> Awaitable[Optional[GaoYongArgs]]:
logic = UserV2Logic(logger)
user = async_to_sync(logic.get_user_by_token(self.token))
if user is None:
logger.bind(token=self.token).error("user token is invalid")
# noinspection PyTypeChecker
return None
pid = SConfig.AliPid
sid = SConfig.ZTKSid
args = GaoYongArgs(num_iid=self.item_id, pid=pid, sid=sid)
try:
info = TBChannelIdModel.objects.get(user=user)
if info.relation_id is not None:
args.relation_id = info.relation_id
if info.special_id is not None:
args.special_id = info.special_id
# noinspection PyTypeChecker
return args
except ObjectDoesNotExist:
logger.bind(user=user).error("user not bind taobao")
# noinspection PyTypeChecker
return args
def _do_get_order_list(
args: TbServiceGetOrderDetailsArgs, logger: BoundLogger
) -> Optional[OrderDetailsResp]:
dtk = DtkSyncApi(SConfig.DTKAppKey, SConfig.DTKAppSecret)
ret = dtk.tb_service_get_order_details(args)
logger.bind(ret=ret).info("get data")
if ret is None:
return None
return OrderDetailsResp.from_result(ret)
def _process_order(self, order: OrderDto, logger: BoundLogger):
"""
处理一个订单的信息
:param order: 处理订单
:return:
"""
try:
return self._do_process_order(order, logger)
except Exception as e:
logger.bind(exception=e).error("process order failed")
def _do_update_old_order(order: OrderDto, model: OrderModel,
logger: BoundLogger):
"""
更新一个订单信息
当前的订单信息为 order
数据库中的信息为 model
:param order:
:param model:
:param logger:
:return:
"""
model.order_ctime = order.order_ctime()
model.order_status = str(order.tk_status)
model.pay_price = order.ali_pay_price()
model.pay_time = order.pay_time()
model.end_time = order.end_time()
model.income = order.income()
model.score = (int(order.income() * 100), )
model.detail = order.to_dict()
if order.is_order_paid(): # 默认状态
model.status = OrderStatusEnum.wait
elif order.is_order_canceled(): # 需要查询之前的状态
if model.status == OrderStatusEnum.wait:
model.status = OrderStatusEnum.cancel
elif model.status == OrderStatusEnum.cancel: # 已经是这个状态 没有必要更新
pass
elif model.status == OrderStatusEnum.success:
logger.bind(order_no=order.trade_id).error("revoke score ?")
model.status = OrderStatusEnum.cancel
elif order.is_order_success() or order.is_order_done():
if model.status == OrderStatusEnum.wait: # 之前的状态是等待 现在变成 成功状态
event = f"购买: {order.trade_id}"
logic = UserV2Logic(logger)
logic.add_score(model.user, event, int(order.income() * 100))
model.status = OrderStatusEnum.success
elif model.status == OrderStatusEnum.cancel: # 取消之后不可能成功
logger.bind(
order_no=order.trade_id).error("sth impossible happened")
elif model.status == OrderStatusEnum.success: # 已经是这个状态 没有必要更新
pass
# noinspection PyArgumentList
model.save()
def _do_get_order_list(args: NewOrderArgs,
logger: BoundLogger) -> Optional[OrderDetailsResp]:
args.sid = SConfig.ZTKSid
ztk = ZTKSync(args.sid, logger)
ret = ztk.new_order(args)
if not isinstance(ret, dict):
logger.bind(ret=ret).error("get ztk failed")
return None
if "url" not in ret:
logger.bind(ret=ret).error("not found url")
return None
url = ret["url"]
data = requests.get(url)
j = data.json()
ret = OrderDetailsResp.from_result(j)
return ret
def cond_bind(log: BoundLogger,
state: Dict[str, Any],
key: str,
as_key: Optional[str] = None) -> BoundLogger:
"""Conditionally (on presence of key) build Structlog context."""
if as_key is None:
as_key = key
if key in state:
return log.bind(**{as_key: state[key]})
return log
async def ingest_ltd_lander_jsonld_document(
*,
app: web.Application,
logger: BoundLogger,
url_ingest_message: Dict[str, Any],
) -> None:
"""Run the Algolia ingest of a LTD_LANDER_JSONLD content type.
Parameters
----------
app : `aiohttp.web.Application`
The app.
logger
A structlog logger that is bound with context about the Kafka message.
url_ingest_message : `dict`
The deserialized value of the Kafka message.
"""
logger = logger.bind(
content_url=url_ingest_message["url"],
content_type=url_ingest_message["content_type"],
)
logger.info("Starting LTD_LANDER_JSONLD ingest")
http_session = app["safir/http_session"]
edition_data = await get_json_data(
url=url_ingest_message["edition"]["url"],
logger=logger,
http_session=http_session,
)
published_url = edition_data["published_url"]
jsonld_name = "metadata.jsonld"
if published_url.endswith("/"):
jsonld_url = f"{published_url}{jsonld_name}"
else:
jsonld_url = f"{published_url}/{jsonld_name}"
try:
metadata = await get_json_data(
url=jsonld_url,
logger=logger,
http_session=http_session,
# by-pass aiohttp's encoding check; the jsonld files do not have
# correct CONTENT-TYPE headers.
encoding="utf-8",
content_type=None,
)
except Exception:
logger.exception("Failure getting metadata.jsonld",
jsonld_url=jsonld_url)
raise
try:
reduced_document = ReducedLtdLanderDocument(url=published_url,
metadata=metadata,
logger=logger)
except Exception:
logger.exception("Failed to build record")
raise
surrogate_key = generate_surrogate_key()
logger.debug("Reduced LTD Lander Document",
chunks=len(reduced_document.chunks))
try:
records = [
create_record(
chunk=s,
document=reduced_document,
surrogate_key=surrogate_key,
) for s in reduced_document.chunks
]
description_chunk = ContentChunk(
headers=[reduced_document.h1],
content=reduced_document.description,
)
records.append(
create_record(
chunk=description_chunk,
document=reduced_document,
surrogate_key=surrogate_key,
))
except Exception:
logger.exception("Failed to build records")
raise
logger.info("Finished building records")
if app["ook/algolia_search"] is not None:
try:
client = app["ook/algolia_search"]
index = client.init_index(
app["safir/config"].algolia_document_index_name)
except Exception:
logger.exception(
"Error initializing Algolia index",
index_name=app["safir/config"].algolia_document_index_name,
)
raise
tasks = [index.save_object_async(record) for record in records]
try:
results = await asyncio.gather(*tasks)
MultipleResponse(results).wait()
except Exception:
logger.error("Got algoliasearch request error")
for record in records:
logger.debug(json.dumps(record, indent=2, sort_keys=True))
logger.info("Finished uploading to Algolia")
await delete_old_records(
index=index,
base_url=records[0]["baseUrl"],
surrogate_key=surrogate_key,
logger=logger,
)
async def auth_logger_dependency(
user: str = Depends(auth_dependency),
logger: BoundLogger = Depends(logger_dependency),
) -> BoundLogger:
"""Logger bound to the authenticated user."""
return logger.bind(user=user)
