async def deal_out(income: sch_in.DealRequest):
transaction = await database.transaction()
try:
rlts = await crud_dl.update_goods(income.items, deal_is_out=True)
if None in rlts:
await transaction.rollback()
return sch_db.Report(ok=False,
code=2,
msg="Barcode error",
data=crud_dl.get_unknow_barcode(
income.items, rlts))
quant = [e['quantity'] for e in rlts]
if any(elem < 0 for elem in quant):
await transaction.rollback()
return sch_db.Report(ok=False,
code=3,
msg="Not enough quantity",
data=crud_dl.get_negavite_quant(
income.items, quant))
deal_uuid = uuid.uuid4()
deal_id, _ = await crud_dl.create_deal(
deal_uuid, await crud_us.get_or_create_user(income.id),
crud_dl.get_amount(income.items, rlts))
await crud_dl.update_countbook(income.items,
rlts,
deal_id,
deal_is_out=True)
except Exception as e:
await transaction.rollback()
logger.warning(f"deal_out: Exception: {e}")
return sch_db.Report(ok=False, code=1, msg="Unknown error")
else:
await transaction.commit()
return sch_db.Report(ok=True, code=0, msg="Buy deal done", data=deal_uuid)
async def deal_in(income: sch_in.DealRequest):
transaction = await database.transaction()
try:
rlts = await crud_dl.update_goods(income.items, deal_is_out=False)
if None in rlts:
await transaction.rollback()
return sch_db.Report(ok=False,
code=2,
msg="Barcode error",
data=crud_dl.get_unknow_barcode(
income.items, rlts))
deal_uuid = uuid.uuid4()
deal_id, balance = await crud_dl.create_deal(
deal_uuid, await crud_us.get_or_create_user(income.id),
-crud_dl.get_amount(income.items, rlts))
if balance < 0:
await transaction.rollback()
return sch_db.Report(ok=False, code=3, msg="Not enough money")
await crud_dl.update_countbook(income.items,
rlts,
deal_id,
deal_is_out=False)
except Exception as e:
await transaction.rollback()
logger.warning(f"deal_in: Exception: {e}")
return sch_db.Report(ok=False, code=1, msg="Unknown error")
else:
await transaction.commit()
return sch_db.Report(ok=True, code=0, msg="Sell deal done", data=deal_uuid)
async def login(user_name: str, password: str) -> str:
"""Obtain a token form RW API using given user name and password."""
headers = {"Content-Type": "application/json"}
payload = {"email": user_name, "password": password}
logger.debug(
f"Requesting Bearer token from GFW production API for user {user_name}"
)
url = f"{RW_API_URL}/auth/login"
try:
async with AsyncClient() as client:
response: HTTPXResponse = await client.post(
url, json=payload, headers=headers
)
except ReadTimeout:
raise HTTPException(
status_code=500,
detail="Call to authorization server timed-out. Please try again.",
)
if response.status_code != 200:
logger.warning(
f"Authentication for user {user_name} failed. API responded with status code {response.status_code} and message {response.text}"
)
raise UnauthorizedError("Authentication failed")
return response.json()["data"]["token"]
def get_current_user(db: Session = Depends(get_db),
token: str = Depends(oauth2_scheme)) -> models.User:
"""Return the current user based on the bearer token from the header"""
credentials_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Could not validate credentials",
headers={"WWW-Authenticate": "Bearer"},
)
try:
payload = utils.decode_access_token(token)
except ExpiredSignatureError:
msg = "Token has expired"
logger.warning(msg)
credentials_exception.detail = msg
raise credentials_exception
except PyJWTError as e:
logger.warning(f"Error decoding JWT: {e}")
raise credentials_exception
username = payload.get("sub")
if username is None:
msg = "Missing subject claim in JWT"
logger.warning(msg)
credentials_exception.detail = msg
raise credentials_exception
user = crud.get_user_by_username(db, username)
if user is None:
msg = f"Unknown user {username}"
logger.warning(msg)
credentials_exception.detail = msg
raise credentials_exception
if not user.is_active:
logger.warning(f"User {username} is inactive")
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN,
detail="Inactive user")
return user
async def turn_on(code: str):
try:
out = await Linker.switch_on_state(code=code, turn_on=False)
return schm.ReportSimple(ok=True) if out else schm.ReportSimple(ok=False)
except Exception as e:
logger.warning(f"turn_on - {code} - Exception [{type(e)}]: {e}")
return schm.ReportSimple(ok=False)
async def go_send_all_email(dir_name: str, background_tasks: BackgroundTasks):
tickets = get_tickets(sheet_name=dir_name)
update_drive_img_dirs(drive_img_dirs)
send_list = list()
for number, title, words, name, email, is_sent in tickets[dir_name]:
if email and name and is_sent == '0':
try:
img_id = get_img_id(dir_name, f'{name}.png', drive_img_dirs)
message = dict(
to_email=email,
from_email=settings.FROM_EMAIL,
subject='神駒團愛你',
html_content=f'<strong>{words} - {name}</strong>',
file_type='image/png',
file_id=img_id,
file_name=f'{name}.png',
)
succeed = await send_mail(message)
if succeed:
send_list.append(number)
else:
logger.warning(f'Fail to send the mail ({email})!!')
except Exception as e:
logger.warning(f'Fail to send the mail ({email})!!')
logger.info('Finish sending all mails!!')
logger.info(f'Updating the column "is_sent" of sheet ({dir_name})')
background_tasks.add_task(updae_is_sent_list, dir_name, send_list)
return {'info': 'Finish sending all mails!!'}
async def login_post(
request: Request,
db: Session = Depends(deps.get_db),
):
form = await request.form()
username = form.get("username", "").lower().strip()
password = form.get("password", "").strip()
result = {
"request": request,
"username": username,
"password": password,
"error": "",
}
if not username or not password:
result["error"] = "You must specify a username and password"
return templates.TemplateResponse("login.html", result)
if not auth.authenticate_user(username, password):
logger.warning(f"Authentication failed for {username}")
result["error"] = "Invalid Username/Password"
return templates.TemplateResponse("login.html", result)
logger.info(f"User {username} successfully logged in")
db_user = crud.get_user_by_username(db, username.lower())
if db_user is None:
db_user = crud.create_user(db, username.lower())
resp = RedirectResponse("/", status_code=status.HTTP_302_FOUND)
cookie_auth.set_auth(resp, db_user.id)
return resp
async def get_link_or_none(
cls,
code: str) -> Tuple[Optional[Dict[str, Any]], schm.LinkerGetSrc]:
if await cls.bag_nolink.has(code):
return None, schm.LinkerGetSrc.RDS
rds_val = await RdsOpr.raw().hgetall(code)
if rds_val:
return rds_val, schm.LinkerGetSrc.RDS
try:
db_val, is_on = await crud_rdir.get_redirect_by_code(code)
data = {
'link': db_val,
'is_on': is_on
} # todo - switch to pydantic model maybe
await RdsOpr.raw().hmset_dict(code, data)
await RdsOpr.raw().expire(code, cls.cache_ttl)
return data, schm.LinkerGetSrc.DB_OK
except TypeError as e:
await cls.bag_nolink.add(code)
return None, schm.LinkerGetSrc.DB_OK
except Exception as e:
logger.warning(
f"get_link_or_none - {code} - Exception [{type(e)}]: {e}")
await cls.bag_nolink.add(code)
return None, schm.LinkerGetSrc.DB_ERR
async def send_push(
client: httpx.AsyncClient,
apn: str,
payload: schemas.ApnPayload,
db: Session,
user: models.User,
) -> bool:
"""Send a push notification to iOS
Return True in case of success
"""
logger.info(f"Send notification to {user.username} (apn: {apn[:10]}...)")
try:
response = await client.post(f"https://{APPLE_SERVER}/3/device/{apn}",
json=payload.dict())
response.raise_for_status()
except httpx.RequestError as exc:
logger.error(f"HTTP Exception for {exc.request.url} - {exc}")
return False
except httpx.HTTPStatusError as exc:
logger.warning(f"{exc}")
if response.status_code == 410:
logger.info(
f"Device token no longer active. Delete {apn} for user {user.username}"
)
crud.remove_user_device_token(db, user, apn)
return False
logger.info(f"Notification sent to user {user.username}")
return True
async def who_am_i(token) -> Response:
"""Call GFW API to get token's identity."""
headers = {"Authorization": f"Bearer {token}"}
url = f"{RW_API_URL}/auth/check-logged"
try:
async with AsyncClient() as client:
response: HTTPXResponse = await client.get(
url, headers=headers, timeout=10.0
)
except ReadTimeout:
raise HTTPException(
status_code=500,
detail="Call to authorization server timed-out. Please try again.",
)
if response.status_code != 200 and response.status_code != 401:
logger.warning(
f"Failed to authorize user. Server responded with response code: {response.status_code} and message: {response.text}"
)
raise HTTPException(
status_code=500, detail="Call to authorization server failed"
)
return response
async def send_kakao(request: Request, body: KakaoMsgBody):
#https://developers.kakao.com/docs/latest/ko/message/rest-api
#카카오톡 디벨롭에 들어가서 엑세스 키 받기
token = op.environ.get(
"KAKAO_KEY",
"ff7f8773-a41e-4198-91a6-3ce23715-7a41-43bd-83e1-2894cbb7c4e8")
headers = {
"Authorization": f"Bearer {token}",
"Content-Type": "application/x-www-form-urlencoded"
}
body = dict(object_type="text",
text=body.msg,
link=dict(web_url="", mobile_url=""),
button_title="")
data = {"template_object": json.dumps(body, ensure_ascii=False)}
res = requests.post("https://kapi.kakao.com/v2/api/talk/memo/default/send",
headers=headers,
data=data)
try:
res.raise_for_status()
if res.json()["result_code"] != 0:
raise Exception("KAKAO SEND FAILED")
except Exception as e:
print(res.json())
logger.warning(e)
raise ex.KakaoSendFailureEx
return MessageOk()
async def session_commit(*args, **kwargs):
db: Session = kwargs.get('db')
try:
return await func(*args, **kwargs)
except Exception as e:
logger.error('db operation error，here are details{}'.format(e))
logger.warning('transaction rollbacks')
db.rollback()
def update_drive_img_dirs(img_dirs: Dict):
if img_dirs is None:
logger.warning(f'img_dirs can not be None!!')
return
_img_dirs = get_dir_list(dir_only=True)
for title, _id in _img_dirs.items():
if title not in img_dirs and '.' not in title:
img_dirs[title] = {'id': _id, 'files': get_dir_list(q_id=_id)}
def logger(self, msg, level="info"):
if level == "info":
logger.info(
f"{level.upper()}[{datetime.now().strftime('%d/%m/%Y %H:%M:%S')}]: {msg}"
)
if level == "warning":
logger.warning(
f"{level.upper()}[{datetime.now().strftime('%d/%m/%Y %H:%M:%S')}]: {msg}"
)
def __get_proj_commune_maintainer(self, project):
user = project.metadata.commune.user_in_charge
if user != None:
return user.email
log_commune_obj = project.metadata.commune.to_mongo().to_dict()
logger.warning(
'EmailSender_WARNING. Missing user_in_charge for commune {}'.
format(log_commune_obj))
return None
async def make(self):
if not os.path.exists(self.index_directory):
logger.warning("index for BERTQuestionAnswering missing")
await self.index(force=True)
self.qa = text.SimpleQA(
index_dir=self.index_directory,
bert_squad_model=self.bert_squad_model,
bert_emb_model=self.bert_emb_model,
)
async def get_info_link(code: str):
try:
redirect, src = await Linker.get_link_or_none(code)
logger.debug(f'Linker return - {code} - {redirect} - {src}')
if redirect is None:
return schm.ReportLink(ok=False)
return schm.ReportLink(ok=True, link=redirect['link'], is_on=redirect['is_on'])
except Exception as e:
logger.warning(f"get_link - {code} - Exception [{type(e)}]: {e}")
return schm.ReportLink(ok=False)
def is_valid_pob(pob_build_xml: bytes) -> bool:
schema_doc = etree.XML(XSD_CONTENT)
schema = etree.XMLSchema(schema_doc)
parser = etree.XMLParser(schema=schema)
try:
etree.XML(pob_build_xml, parser)
except etree.XMLSyntaxError as e:
logger.warning(f"Incoming build does not match DTD: '{e}'")
return False
return True
async def get_competitors(self):
try:
competitors = []
cursor = await r.db('competition').table("competitors").run(self._conn)
async for document in cursor:
competitors.append(document)
return competitors
except ReqlOpFailedError as err:
logger.warning(f"DB Error: {err}")
return []
def sample():
logger.critical('CRITICAL message')
logger.error('ERROR message')
logger.warning('WARNING message')
logger.info('INFO message')
logger.debug('DEBUG message')
module()
return 'hello, world'
async def initial_deal():
try:
query = sa.select([deals]).order_by(deals.c.created_at.desc()).limit(1)
rlt = await database.execute(query)
if not rlt:
query = deals.insert().values(uuid=uuid.uuid4(),
balance=0.0).returning(deals.c.uuid)
rlt = await database.execute(query)
logger.info(f"Initial deal created {rlt}")
except Exception as e:
logger.warning(f"initial_deal: Exception: {e}")
async def setup_db(self):
try:
self._conn = await r.connect(self._conn_string, self._port)
if "competition" not in await r.db_list().run(self._conn): # setup db and tables
await r.db_create("competition").run(self._conn)
await r.db('competition').table_create('competitors').run(self._conn)
except ReqlDriverError as err:
logger.warning(f"Could not connect to DB: {err}")
except ReqlOpFailedError as ex:
logger.warning(f"DB creation error: {ex}")
self._db_is_setup = True
async def get_balance():
try:
query = sa.select([deals.c.balance
]).order_by(deals.c.id.desc()).limit(1)
rlt = await database.execute(query)
return sch_db.ReportBalance(ok=True,
code=0,
msg="Current balance",
data=rlt)
except Exception as e:
logger.warning(f"get_balance: Exception: {e}")
return sch_db.ReportBalance(ok=False, code=1, msg="Unknown error")
def get_current_admin_user(
current_user: models.User = Depends(get_current_user),
) -> models.User:
"""Return the current user only if he is admin"""
if not current_user.is_admin:
logger.warning(
f"User {current_user.username} doesn't have enough privileges")
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="The user doesn't have enough privileges",
)
return current_user
async def update_on_state(code: str, turn_on: bool) -> bool:
try:
query = md.redirect.update()\
.where(md.redirect.c.code == code)\
.values(is_on=turn_on)\
.returning(md.redirect.c.code)
out = await database.execute(query)
return True if out is not None else False
except Exception as e:
logger.warning(
f"update_on_state - {code} - Exception [{type(e)}]: {e}")
return False
async def get_items(q: str = Query(...,
min_length=5,
max_length=50,
regex="^fixedquery$")):
try:
results = [{"item_id": "Foo"}, {"item_id": "Bar"}]
if q:
logger.info(type(q))
results.append({"q": q})
return results
except AttributeError as e:
logger.warning(msg=e)
async def send_mail(message: Union[Dict, EmailSchema, EmailAttachFileSchema]):
message = message if isinstance(message, Dict) else message.dict()
email = generate_email(**message)
succeed = False
try:
sg = get_sg_client()
response = sg.send(email)
logger.info('send mail status_code: ' + str(response.status_code))
succeed = response.status_code >= 200
# logger.info('response body: ' + str(response.body))
# logger.info('response header' + str(response.headers))
except Exception as e:
logger.warning(f'Error: {str(e)}')
return succeed
async def get_record_data(
*,
db: Session = Depends(get_db),
record_id: UUID,
accept: Optional[str] = Header(default="application/json"),
) -> Any:
if accept == "application/x-dataframe":
logger.warning(
"Accept with 'application/x-dataframe' is deprecated. Use 'text/csv' instead."
)
accept = "text/csv"
record = db.query(ds.Record).filter_by(id=record_id).one()
return await _get_record_data(record, accept)
async def switcher_handle(rqst: schemas.Rqst):
try:
if rqst.sess.state == state_holder.zero:
return await case_zero.handle(rqst)
if rqst.sess.state == state_holder.buy:
return await case_buy.handle(rqst)
except BotExceptionNoUser as e:
logger.warning(
f"BotExceptionNoUser for {rqst.chat_id} where {e.where}")
await tg_driver.send_msg(rqst.chat_id, msg_switcher.no_user)
await rdsopr.raw().delete(rqst.chat_id)
except Exception as e:
logger.warning(f"Exception in switcher for {rqst.chat_id} with {e}")
return
async def merge_branches(merge: Merge, background_tasks: BackgroundTasks):
"""
Simple endpoint to simulate a shared resource we want to merge that must
be locked when active. We simulate for 10 seconds.
"""
global _shared_resources_dict
if _shared_resources_dict.get(merge.branch_name):
logger.warning("We got a request but the shared resource is in use!")
raise HTTPException(
status_code=400,
detail=f"Branch {merge.branch_name} already in use!")
background_tasks.add_task(use_shared_resource, merge.branch_name)
return {'message': f'merge for branch: {merge.branch_name} in progress'}
