async def get(self, _id=None, alias=None, **kwargs):
from motorengine.query_builder.node import Q
if _id is None and not kwargs:
raise RuntimeError(
'Either an id or a filter must be provided to get')
if _id is not None:
if not isinstance(_id, ObjectId):
_id = ObjectId(_id)
filters = {'_id': _id}
else:
filters = Q(**kwargs)
filters = self.get_query_from_filters(filters)
instance = await self.coll(alias).find_one(
filters, projection=self._loaded_fields.to_query(self.__klass__))
if instance is None:
return
else:
doc = self._resolve_class(instance).from_son(
instance,
_is_partly_loaded=bool(self._loaded_fields),
_reference_loaded_fields=self._reference_loaded_fields)
if self.is_lazy:
return doc
else:
await doc.load_references()
return doc
def __init__(self, aggregation, *args, **filters):
super(Match, self).__init__(aggregation)
if args and len(args) == 1 and isinstance(args[0],
(Q, QNot, QCombination)):
self.filters = args[0]
else:
self.filters = Q(**filters)
def get(self):
query = Q(status='ACTIVE')
if self.query:
q = '.*%s.*' % self.query
query = query & Q({"name": {'$regex': q}})
qs = User.objects.filter(query).order_by('create_at',
direction=DESCENDING)
if self.page:
skip = self.count_per_page * (self.page - 1)
limit = self.count_per_page
qs = qs.skip(skip).limit(limit)
users = yield qs.find_all()
roles = yield Role.objects.find_all()
total = yield User.objects.filter(query).count()
self.context['total'] = total / self.count_per_page
self.context['users'] = users
self.context['roles_display'] = {r.key: r.name for r in roles}
self.render('user_list.html', **self.context)
def filter_not(self, *arguments, **kwargs):
from motorengine.query_builder.node import Q, QCombination, QNot
if arguments and len(arguments) == 1 and isinstance(
arguments[0], (Q, QCombination)):
self.filter(QNot(arguments[0]))
else:
self.filter(QNot(Q(**kwargs)))
return self
def filter(self, *arguments, **kwargs):
if arguments and len(arguments) == 1 and isinstance(
arguments[0], (Q, QNot, QCombination)):
if self._filters:
self._filters = self._filters & arguments[0]
else:
self._filters = arguments[0]
else:
validate_fields(self.__klass__, kwargs)
if self._filters:
self._filters = self._filters & Q(**kwargs)
else:
if arguments and len(arguments) == 1 and isinstance(
arguments[0], dict):
self._filters = Q(arguments[0])
else:
self._filters = Q(**kwargs)
return self
def get(self):
query = Q(status='ACTIVE')
if self.query:
q = '.*%s.*' % self.query
query = query & (
Q({"sku": {'$regex': q}})
| Q({"name": {'$regex': q}})
| Q({"id_from_source": {'$regex': q}})
| Q({"price_for_ref": {'$regex': q}})
)
qs = Product.objects.filter(query).order_by('create_at',
direction=DESCENDING)
if self.page:
skip = self.count_per_page * (self.page - 1)
limit = self.count_per_page
qs = qs.skip(skip).limit(limit)
products = yield qs.find_all()
total = yield Product.objects.filter(query).count()
self.context['total'] = total / self.count_per_page
self.context['products'] = products
self.render('product_list.html', **self.context)
def get(self):
query = Q(status='ACTIVE')
if self.query:
q = '.*%s.*' % self.query
query = query & (
Q({"source": {'$regex': q}})
| Q({"seller": {'$regex': q}})
)
qs = Order.objects.filter(query).order_by(
'deliver_at', direction=DESCENDING)
if self.page:
skip = self.count_per_page * (self.page - 1)
limit = self.count_per_page
qs = qs.skip(skip).limit(limit)
orders = yield qs.find_all()
yards = yield Yard.objects.find_all()
products = yield Product.objects.find_all()
total = yield Order.objects.filter(query).count()
self.context['total'] = total / self.count_per_page
self.context['orders'] = orders
self.context['yards'] = yards
self.context['products'] = products
self.render('order_list.html', **self.context)
async def get(self, _id=None, callback=None, alias=None, **kwargs):
from motorengine.query_builder.node import Q
if _id is None and not kwargs:
raise RuntimeError(
'Either an id or a filter must be provided to get')
if _id is not None:
if not isinstance(_id, ObjectId):
_id = ObjectId(_id)
filters = {'_id': _id}
else:
filters = Q(**kwargs)
filters = self.get_query_from_filters(filters)
await self.coll(alias).find_one(
filters,
projection=self._loaded_fields.to_query(self.__klass__),
callback=self.handle_get(callback))
def __init__(self, klass):
if klass.__abstract__ is True:
raise Exception(
'Abstract model \'{}\' could not be used for retrieving data'.
format(klass.__name__))
self.__klass__ = klass
self._filters = None
self._limit = None
self._skip = None
self._order_fields = []
self._loaded_fields = QueryFieldList()
self._reference_loaded_fields = {}
if klass.__inherit__ is True:
child_classes = [
klass.__hierarchy__,
]
child_classes.extend([
child_class.__hierarchy__
for child_class in klass.__child_classes__
])
self._filters = Q({'_cls': {'$in': child_classes}})
def get(self):
query = Q(status='ACTIVE')
if self.query:
q = '.*%s.*' % self.query
query = query & (
Q({"source": {'$regex': q}})
| Q({"name": {'$regex': q}})
| Q({"region": {'$regex': q}})
| Q({"phone": {'$regex': q}})
| Q({"address": {'$regex': q}})
)
qs = Yard.objects.filter(query).order_by('create_at',
direction=DESCENDING)
if self.page:
skip = self.count_per_page * (self.page - 1)
limit = self.count_per_page
qs = qs.skip(skip).limit(limit)
yards = yield qs.find_all()
total = yield Yard.objects.filter(query).count()
self.context['total'] = total / self.count_per_page
self.context['yards'] = yards
self.render('yard_list.html', **self.context)