def append_select(self, p_select: ModelSelect):
if not self.b_initialized:
return p_select
expression = None
# TODO, this needs to be tested with dateline
for bounds in self.query_params.bounds:
xmin = bounds.xmin
ymin = bounds.ymin
xmax = bounds.xmax
ymax = bounds.ymax
a = (xmin <= self.west_field) & (xmax >= self.west_field)
b = (xmin >= self.west_field) & (self.east_field >= xmin)
ab = a | b
c = (self.south_field <= ymin) & (self.north_field >= ymin)
d = (self.south_field > ymin) & (ymax >= self.south_field)
cd = c | d
abcd = ab & cd
expression_part = abcd
if not expression:
expression = expression_part
else:
expression = expression | expression_part
# TODO process append_select for geometries:
# for polygon_wkb in self.query_params.geometry_bag.geometry_binaries:
if expression:
return p_select.where(expression)
return p_select
def create_search_query(db_model: Type[Model], query: ModelSelect,
data: dict = None) -> ModelSelect:
if data is None:
data = {}
filters = data.get('search', {})
sql_expressions = []
helper = Helper()
for filter in filters:
field = getattr(db_model, filter['field_name'])
field_value = filter['field_value']
if isinstance(field_value, str) and not field_value.strip():
continue
sql_expression = helper.build_sql_expression(field,
filter['field_operator'],
field_value)
sql_expressions.append(sql_expression)
if sql_expressions:
query = query.where(*sql_expressions)
return query
def apply_filter(self, query: ModelSelect, _filter: Dict[str, Any]):
for key, value in _filter.items():
if key.endswith('__not'):
query = query.where(
getattr(self.entity_class, key.replace("__not", "")) !=
value)
elif key.endswith('__in'):
query = query.where(
getattr(self.entity_class, key.replace("__in", "")) in
value)
elif key.endswith('__gt'):
query = query.where(
getattr(self.entity_class, key.replace("__gt", "")) > value
)
elif key.endswith('__gte'):
query = query.where(
getattr(self.entity_class, key.replace("__gte", "")) >=
value)
elif key.endswith('__lt'):
query = query.where(
getattr(self.entity_class, key.replace("__gt", "")) < value
)
elif key.endswith('__lte'):
query = query.where(
getattr(self.entity_class, key.replace("__gte", "")) <=
value)
elif '__' not in key:
query = query.where(
getattr(self.entity_class, key.replace("__gte", "")) ==
value)
return query
def get_data_for_sending(query: ModelSelect, require_where=False):
page, limit, where_count = 1, Config.DEFAULT_API_LIST_LIMIT, 0
for arg_name, arg_value in request.args.items():
if len(arg_value) == 0:
continue
if arg_name in ("order_by", "order_by_desc"):
fields = get_fields_by_names(query.model, [arg_value])
if len(fields) == 0:
abort(400)
field = fields[0] if "order_by" == arg_name else fields[0].desc()
query = query.order_by(field)
elif arg_name == "page":
page = int(arg_value)
elif arg_name == "limit":
limit = int(arg_value)
limit = limit if limit <= Config.MAX_API_LIST_LIMIT else Config.MAX_API_LIST_LIMIT
elif arg_name.startswith("where:") or arg_name.startswith("or_where:"):
operations = arg_name.split(":")
is_or_where = operations[0] == "or_where"
if len(operations) == 2:
operator = "equal"
else:
operator = operations[1]
fields = get_fields_by_names(query.model, [operations[-1]])
if len(fields) == 0:
abort(400)
else:
field = fields[0]
expression = get_expression_by_operator(field, arg_value, operator)
if expression is None:
abort(400)
if is_or_where:
query = query.orwhere(expression)
else:
query = query.where(expression)
where_count += 1
if require_where and where_count == 0:
abort(400)
count = query.count()
if count == 0:
abort(404)
pages_count = math.ceil(count / limit)
data = [get_model_dict(sm) for sm in query.paginate(page, limit)]
return {
"data": data,
"page": page,
"pages": pages_count,
"count": count,
"limit": limit
}
def append_select(self, p_select: ModelSelect):
if self.query_params.sort_direction == epl_imagery_pb2.ASCENDING:
p_select = p_select.order_by(self.field)
elif self.query_params.sort_direction == epl_imagery_pb2.DESCENDING:
p_select = p_select.order_by(self.field.desc())
if self.query_params.values or self.query_params.excluded_values:
if self.query_params.values:
p_select = p_select.where(
self.field << list(self.query_params.values))
if self.query_params.excluded_values:
p_select = p_select.where(
~(self.field << list(self.query_params.excluded_values)))
if self.query_params.include_ranges:
p_select = p_select.where(
self._append_ranges(self.query_params.include_ranges, False))
if self.query_params.exclude_ranges:
p_select = p_select.where(
self._append_ranges(self.query_params.exclude_ranges, True))
return p_select
async def get_or_404(
query: ModelSelect,
*conditions: Any,
prefetches: Optional[Any] = None,
**filters: Any,
) -> PeeweeModel:
if conditions:
query = query.where(*conditions)
elif filters:
query = query.filter(**filters)
query = prefetch(query, *prefetches) if prefetches else execute(query)
obj = first(await query)
if obj is None:
raise NotFound
return obj # type: ignore
def append_select(self, p_select: ModelSelect):
if not self.b_initialized:
return p_select
expression = None
for i in range(0, len(self.query_params.values), 2):
left_val = self.query_params.values[i]
right_val = self.query_params.values[i + 1]
expression_part = (self.left_field == left_val).bin_and(
self.right_field == right_val)
if not expression:
expression = expression_part
else:
expression = (expression | expression_part)
return p_select.where(expression)