def query_space_with_pagination(query_name: str, pagination: Pagination):
items_count = spaces.find({"name": regex.Regex(query_name)}).count()
skips = pagination.pageSize * (pagination.pageNumber - 1)
result = spaces.find({
"name": regex.Regex(query_name)
}).skip(skips).limit(pagination.pageSize)
return build_data_pages(pagination, list(result), items_count)
def query_topic_list_with_pagination(query_name: str, pagination: Pagination):
item_count = topics.find({"name": regex.Regex(query_name)}).count()
skips = pagination.pageSize * (pagination.pageNumber - 1)
result = topics.find({
"name": regex.Regex(query_name)
}).skip(skips).limit(pagination.pageSize).sort("last_modified",
pymongo.DESCENDING)
return build_data_pages(pagination, list(result), item_count)
def query_topic_list_with_pagination(query_name: str, pagination: Pagination):
return template.query_with_pagination(
TOPICS,
pagination,
Topic,
query_dict={"name": regex.Regex(query_name)},
sort_dict=["last_modified", pymongo.DESCENDING])
def query_report_list_with_pagination(query_name: str, pagination: Pagination):
return template.query_with_pagination(
CONSOLE_REPORTS,
pagination,
Report,
query_dict={"name": regex.Regex(query_name)},
sort_dict=["last_modified", pymongo.DESCENDING])
def query_enum_list_with_pagination(query_name: str, pagination: Pagination):
return template.query_with_pagination(
ENUMS,
pagination,
Enum,
query_dict={"name": regex.Regex(query_name)},
sort_dict=["last_modified", pymongo.DESCENDING])
def build_mongo_where_expression(where: dict):
for key, value in where.items():
if key == "and" or key == "or":
if isinstance(value, list):
filters = []
for express in value:
result = build_mongo_where_expression(express)
filters.append(result)
if key == "and":
return {"$and": filters}
if key == "or":
return {"$or": filters}
else:
if isinstance(value, dict):
for k, v in value.items():
if k == "=":
return {key: {"$eq": v}}
if k == "like":
return {key: regex.Regex(v)}
if k == "in":
return {key: {"$in": v}}
if k == ">":
return {key: {"$gt": v}}
if k == ">=":
return {key: {"$gte": v}}
if k == "<":
return {key: {"$lt": v}}
if k == "<=":
return {key: {"$lte": v}}
if k == "between":
if (isinstance(v, tuple)) and len(v) == 2:
return {key: {"$gte": v[0], "$lt": v[1]}}
else:
return {key: {"$eq": value}}
def query_users_by_name_with_pagination(query_name: str,
pagination: Pagination):
# items_count = users.find({"name": regex.Regex(query_name)}).count()
# skips = pagination.pageSize * (pagination.pageNumber - 1)
# result = users.find({"name": regex.Regex(query_name)}).skip(skips).limit(pagination.pageSize)
# return build_data_pages(pagination, list(result), items_count)
return template.query_with_pagination(USERS, pagination, User,
{"name": regex.Regex(query_name)})
def load_user_list_by_name(query_name):
# result = users.find({"name": regex.Regex(query_name)})
# return list(result)
return template.find(USERS, {"name": regex.Regex(query_name)}, User)
def query_user_groups_by_name_with_paginate(query_name: str,
pagination: Pagination):
return template.query_with_pagination(USER_GROUPS, pagination, UserGroup,
{"name": regex.Regex(query_name)})
def load_group_list_by_name(query_name):
return template.find(USER_GROUPS, {"name": regex.Regex(query_name)},
UserGroup)
def load_space_list_by_name(name) -> List[Space]:
return mongo_template.find(SPACES, {"name": regex.Regex(name)}, Space)
def query_space_with_pagination(query_name: str, pagination: Pagination) -> DataPage:
return template.query_with_pagination(SPACES, pagination, Space, {"name": regex.Regex(query_name)})
def load_space_list_by_name(name):
return mongo_template.find("spaces", {"name": regex.Regex(name)}, Space)
def load_topic_list_by_name(topic_name):
result = topics.find({"name": regex.Regex(topic_name)})
return list(result)
def load_topic_list_by_name(topic_name: str) -> List[Topic]:
return template.find(TOPICS, {"name": regex.Regex(topic_name)}, Topic)
def load_space_list_by_name(name):
result = spaces.find({"name": regex.Regex(name)})
return list(result)
def load_enum_list_by_name(enum_name):
return template.find(ENUMS, {"name": regex.Regex(enum_name)}, Enum)
def query_users_by_name_with_pagination(query_name: str,
pagination: Pagination):
return template.query_with_pagination(USERS, pagination, User,
{"name": regex.Regex(query_name)})
def query_space_with_pagination(query_name: str, pagination: Pagination):
return template.query_with_pagination("spaces", pagination, Space,
{"name": regex.Regex(query_name)})
def load_group_list_by_name(query_name):
result = user_groups.find({"name": regex.Regex(query_name)})
return list(result)
def build_mongo_where_expression(self, where: dict):
"""
Build where, the common sql pattern is "column_name operator value", but we use dict,
so the pattern is {column_name: {operator: value}}.
if operator is =, then can use {column_name: value}
About and|or , use
{"and": List(
{column_name1: {operator: value}}
{column_name2: {operator: value}}
)
}
support Nested:
{"or": List(
{column_name1: {operator: value}}
{column_name2: {operator: value}}
{"and": List(
{column_name3:{operator: value}}
{column_name4:{operator: value}}
)
}
)
}
"""
for key, value in where.items():
if key == "and" or key == "or":
if isinstance(value, list):
filters = []
for express in value:
result = self.build_mongo_where_expression(express)
filters.append(result)
if key == "and":
return {"$and": filters}
if key == "or":
return {"$or": filters}
else:
if isinstance(value, dict):
for k, v in value.items():
if k == "=":
return {key: {"$eq": v}}
if k == "!=":
return {key: {"$ne": v}}
if k == "like":
return {key: regex.Regex(v)}
if k == "in":
return {key: {"$in": v}}
if k == "not-in":
return {key: {"$nin": v}}
if k == ">":
return {key: {"$gt": v}}
if k == ">=":
return {key: {"$gte": v}}
if k == "<":
return {key: {"$lt": v}}
if k == "<=":
return {key: {"$lte": v}}
if k == "between":
if (isinstance(v, tuple)) and len(v) == 2:
return {key: {"$gte": v[0], "$lt": v[1]}}
else:
return {key: {"$eq": value}}
