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'}