def get(self,
token: str = Depends(oauth2_scheme),
code: Optional[str] = None):
owner = token2user(token)
self.data_mod.set_owner(owner)
filt = {}
if code != None:
keycols = self.data_mod.cols(attr="key")
filt = {c: code for c in keycols}
df = self.data_mod.select(filt)
if df.empty:
return paginate([])
rtn = self.data_mod.to_dict(df)
return paginate(rtn)
def get_emissions_from_run(
run_id: str,
emission_service: EmissionService = Depends(
Provide[ServerContainer.emission_service]
),
params: Params = Depends(),
) -> Page[Emission]:
return paginate(emission_service.get_emissions_from_run(run_id), params)
async def search_tags(tags: List[str]):
"""
Super user method
"""
note_records = list(itertools.chain(*[await NoteTagTableHandler.get_notes_by_tag(tag) for tag in tags]))
return paginate(
[
{**note_record, "tags": await NoteTagTableHandler.get_note_tags(note_record.get('id'))} for note_record in note_records
]
)
async def get(user_id: int) -> List[NoteInDB]:
#TODO the pagination should be tested. We need to investigate the nested queries
note_items = []
notes_in_db = await db.fetch_all(
notes.select().where(notes.c.user_id==user_id)
)
for note_in_db in notes_in_db:
note_items.append({**note_in_db,
"tags": await NoteTagTableHandler.get_note_tags(note_in_db.get('id'))
})
return paginate(note_items)
def post_job(job: jobs._model):
updcols = jobs.cols(attr="updcol")
keycols = jobs.cols(attr="key")
upd = {j[0]: j[1] for j in job if j[0] in updcols}
key = {j[0]: j[1] for j in job if j[0] in keycols and j[1] != None}
upd.update(key)
rtn, dt = jobs.upsert(upd)
if not (rtn):
raise lib.http_exception(status_code=422,
loc=[upd],
msg="Invalid key value")
return paginate(dt)
async def orm_get_model_list_page(client_key: str,
dict_name: str,
params: Params = Depends()):
"""
Универсальное получение списка с пагинацией
"""
res = await get_some(
client_key=client_key,
dict_name=dict_name,
)
page = paginate(res, params).json()
return page
async def orm_get_model_list_filter_page(
client_key: str,
dict_name: str,
params: Params = Depends(),
body=Body(..., example=EXAMPLE_FILTER_ORDER_BODY)):
"""
Универсальное получение фильтрованного списка с пагинацией
"""
res = await get_some(client_key=client_key,
dict_name=dict_name,
filter=body.get('filter', None),
order_by=body.get('order_by', None))
page = paginate(res, params).json()
return page
async def get_users():
df = pd.DataFrame()
firebase = pyrebase.initialize_app(firebaseConfig)
db = firebase.database()
jobs = db.child("JobList").get()
if type(jobs.val() == None) and len(jobs.val()) == 0:
print("True")
users = []
model = User(Id="None",
JobProvideName="None",
JobName="None",
JobLocation="None",
JobProvNumber="None",
Book="None")
users.append(model)
return paginate(users)
else:
for job in jobs.each():
df = df.append(job.val(),
ignore_index=True,
verify_integrity=False,
sort=False)
df.columns = df.columns.str.upper()
allDatalist = df.to_dict('records')
users = []
for i in range(len(allDatalist)):
model = User(Id=allDatalist[i]['ID'],
JobProvideName=allDatalist[i]['JOBPROVIDENAME'],
JobName=allDatalist[i]['JOBNAME'],
JobLocation=allDatalist[i]['JOBLOCATION'],
JobProvNumber=allDatalist[i]['JOBPROVNUMBER'],
Book=allDatalist[i]['BOOK'])
users.append(model)
return paginate(users)
async def _use_as_page():
T = TypeVar("T")
@use_as_page
class CustomPage(BasePage[T], Generic[T]):
@classmethod
def create(cls, items, total, params):
return cls(
items=items,
total=total,
)
page = paginate([1, 2, 3], PaginationParams(0, 50))
assert isinstance(page, CustomPage)
assert page.items == [1, 2, 3]
assert page.total == 3
def post(self,
token: str = Depends(oauth2_scheme),
code: Optional[str] = None,
data: dict = {}):
owner = token2user(token)
self.data_mod.set_owner(owner)
updcols = self.data_mod.cols(attr="updcol")
keycols = self.data_mod.cols(attr="key")
if code != None:
data.update({c: code for c in keycols})
upd = {k: v for k, v in data.items() if k in updcols}
key = {k: v for k, v in data.items() if k in keycols and v != None}
upd.update(key)
rtn, dt = self.data_mod.upsert(upd)
if not (rtn):
raise lib.http_exception(status_code=422,
loc=[],
msg="Invalid key value")
self.data_mod.save()
return paginate(dt)
async def search(keyword: str, user_id: int):
note_items = []
notes_in_db = await db.fetch_all(
notes.select().where(notes.c.user_id == user_id).where(
or_(
notes.c.title.ilike(f"%{keyword}%"),
notes.c.body.ilike(f"%{keyword}%")
)
)
)
if notes_in_db:
for note_in_db in notes_in_db:
note_items.append({**note_in_db,
"tags": await NoteTagTableHandler.get_note_tags(note_in_db.get('id'))
})
like_tags = await TagsTableHandler.search(keyword)
if len(like_tags) > 0:
for tag in like_tags:
user_notes = await NoteTagTableHandler.get_user_notes_by_tag(user_id, tag)
for user_note in user_notes:
note_items.append({**user_note,
"tags": await NoteTagTableHandler.get_note_tags(user_note.get('id'))
})
return paginate(note_items)
async def get_posts(db: AsyncSession = Depends(get_db)):
"""Get list of of AITA reddit posts."""
posts = await PostsDAL(db).get_all()
return paginate(posts)
async def route(res: Response):
assert res is response()
return paginate([])
async def get_recipes(db: AsyncSession = Depends(get_db)):
recipes = await RecipesDAL(db).get_all()
return paginate(recipes)
def get_news(from_: str = "2021-01-01",
to_: str = "2021-01-08",
db: Session = Depends(get_db),
user_entity: str = Depends(verify_token)):
news = crud.get_news(db, from_=from_, to_=to_)
return paginate(news)
def list_items():
return paginate(get_cacheable_items())
def get_transactions():
return paginate(list(TRANSACTIONS.values()))
def get_news(name: str,
db: Session = Depends(get_db),
user_entity: str = Depends(verify_token)):
result = crud.get_persons(db, name=name)
return paginate(result)
async def route():
return paginate(entities)
def get_job():
# def get_job(token: str = Depends(oauth2_scheme)):
rtn = jobs.to_dict()
return paginate(rtn)