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)