def find(self):
str_skip = self.get_query_argument('skip')
deactivated = self.get_query_argument('deactivated')
search = self.get_query_argument('search')
query = User.objects.order_by(
'update_at', direction=DESCENDING).filter(status__ne='Deleted')
get_all_flag = self.get_query_argument('get_all')
if not deactivated:
query.filter(status__ne='Deactivated')
else:
if search:
q = {'$regex': '.*' + search + '.*', '$options': 'i'}
arg = Q(first_name=q) | Q(last_name=q) | Q(email=q)
query.filter(arg)
skip_val = 0
if str_skip:
skip_val = int(str_skip)
if get_all_flag is None:
query.skip(skip_val).limit(15)
users = yield query.find_all()
self.render_json(users)
def filter(self, *arguments, **kwargs):
'''
Filters a queryset in order to produce a different set of document from subsequent queries.
Usage::
User.objects.filter(first_name="Bernardo").filter(last_name="Bernardo").find_all(callback=handle_all)
# or
User.objects.filter(first_name="Bernardo", starting_year__gt=2010).find_all(callback=handle_all)
The available filter options are the same as used in MongoEngine.
'''
from motorengine.query_builder.node import Q, QCombination, QNot
from motorengine.query_builder.transform import validate_fields
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 test_gets_proper_query_when_or(self):
query = Q(first_name="Someone") | Q(first_name="Else")
query_result = query.to_query(User)
expect(query_result).to_be_like(
{'$or': [{
'whatever': 'Someone'
}, {
'whatever': 'Else'
}]})
def test_gets_proper_query_when_and(self):
query = Q(embedded__test__lte="Test") & Q(first_name="Someone")
query_result = query.to_query(User)
expect(query_result).to_be_like({
"embedded_document.other": {
"$lte": "Test"
},
"whatever": "Someone"
})
def test_can_query_using_not_in_with_real_users(self):
self.create_test_users()
names = ["Someone", "John"]
query = ~Q(first_name__in=names) & Q(last_name="Heynemann")
User.objects.filter(query).find_all(callback=self.stop)
users = self.wait()
expect(users).to_length(1)
expect(users[0].first_name).to_equal("Bernardo")
def find(self):
start_timestamp = self.get_query_argument('start')
end_timestamp = self.get_query_argument('end')
branch = self.get_query_argument('branch')
events = []
start_date = datetime.fromtimestamp(int(start_timestamp))
end_date = datetime.fromtimestamp(int(end_timestamp))
while start_date < end_date:
# reg_day = start_date.strftime('%a').lower()
# reg_scheds = yield InstructorSchedule.objects.filter(day=reg_day, type='regular').find_all()
start_date_string = start_date.strftime('%Y-%m-%d')
start_date_filter = datetime.strptime(start_date_string, '%Y-%m-%d')
# for sched in reg_scheds:
# events.append({
# 'title': sched.instructor.admin.first_name + "'s class \n( Regular )",
# 'start': start_date_string + sched.start.strftime(' %H:%M:%S'),
# 'end': start_date_string + sched.end.strftime(' %H:%M:%S'),
# 'instructor': sched.instructor,
# 'start_time': sched.start.strftime('%I:%M %p'),
# 'end_time': sched.end.strftime('%I:%M %p'),
# 'id': str(sched._id),
# 'type': 'regular',
# 'day': reg_day,
# 'ridersCount': (yield BookedSchedule.objects.filter(status='booked', date=start_date_filter, schedule=sched._id).count())
# })
branch_filter = Q(branch=ObjectId(branch))
if branch == '558272c288b5c73163343c45':
branch_filter = Q(branch=ObjectId(branch)) | Q(branch__exists=False)
spec_scheds = yield InstructorSchedule.objects.filter(date=start_date_filter).filter(branch_filter).find_all()
for sched in spec_scheds:
events.append({
'title': sched.type + ' with ' + sched.instructor.admin.first_name +
(' and ' + sched.sub_instructor.admin.first_name if sched.sub_instructor else ''),
'start': start_date_string + sched.start.strftime(' %H:%M:%S'),
'end': start_date_string + sched.end.strftime(' %H:%M:%S'),
'instructor': sched.instructor,
'sub_instructor': sched.sub_instructor,
'start_time': sched.start.strftime('%I:%M %p'),
'end_time': sched.end.strftime('%I:%M %p'),
'id': str(sched._id),
'type': sched.type,
'seats': sched.seats,
'ridersCount': (yield BookedSchedule.objects.filter(status='booked', date=start_date_filter, schedule=sched._id).count())
})
start_date += timedelta(days=1)
self.render_json(events)
def test_gets_proper_query_when_many_operators(self):
query = (Q(embedded__test__lte="Test")
& Q(first_name="Someone")) | Q(first_name="Else")
query_result = query.to_query(User)
expect(query_result).to_be_like({
'$or': [{
'embedded_document.other': {
'$lte': 'Test'
},
'whatever': 'Someone'
}, {
'whatever': 'Else'
}]
})
def test_can_query_using_q_with_is_null(self):
self.create_test_users()
User.objects.filter(
Q(nullable__is_null=True)).find_all(callback=self.stop)
users = self.wait()
expect(users).to_length(1)
expect(users[0]._id).to_equal(self.user._id)
User.objects.filter(
Q(nullable__is_null=False)).find_all(callback=self.stop)
users = self.wait()
expect(users).to_length(2)
expect(users[0]._id).to_equal(self.user2._id)
expect(users[1]._id).to_equal(self.user3._id)
def get(self, id=None, callback=None, alias=None, **kwargs):
'''
Gets a single item of the current queryset collection using it's id.
In order to query a different database, please specify the `alias` of the database to query.
'''
from motorengine 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)
self.coll(alias).find_one(filters,
projection=self._loaded_fields.to_query(
self.__klass__),
callback=self.handle_get(callback))
def test_can_find_with_multiple_filters(self):
yield from User.objects.create(email="*****@*****.**",
first_name="Bernardo",
last_name="Heynemann")
yield from User.objects.create(email="*****@*****.**",
first_name="Someone",
last_name="Else")
user = yield from User.objects.create(email="*****@*****.**",
first_name="Bernardo",
last_name="Heynemann")
last_user = yield from User.objects.create(email="*****@*****.**",
first_name="Bernardo",
last_name="Silva")
# filter and filter not
users = yield from User.objects\
.filter(email="*****@*****.**")\
.filter_not(first_name="Someone").find_all()
expect(users).to_be_instance_of(list)
expect(users).to_length(1)
first_user = users[0]
expect(first_user._id).to_equal(user._id)
# filter and filter not for Q
from motorengine import Q
users = yield from User.objects\
.filter(email="*****@*****.**")\
.filter_not(Q(first_name="Someone")).find_all()
expect(users).to_be_instance_of(list)
expect(users).to_length(1)
first_user = users[0]
expect(first_user._id).to_equal(user._id)
# filter not and filter not
users = yield from User.objects\
.filter_not(last_name="Heynemann")\
.filter_not(first_name="Someone").find_all()
expect(users).to_be_instance_of(list)
expect(users).to_length(1)
first_user = users[0]
expect(first_user._id).to_equal(last_user._id)
# filter and filter
users = yield from User.objects\
.filter(last_name="Silva")\
.filter(first_name="Bernardo").find_all()
expect(users).to_be_instance_of(list)
expect(users).to_length(1)
expect(users[0]._id).to_equal(last_user._id)
async def get(self,
id=None,
alias=None,
lazy=False,
raw: bool = False,
**kwargs) -> Union[Dict, 'Document', None]:
'''
Gets a single item of the current queryset collection using it's id.
In order to query a different database, please specify the `alias` of the database to query.
Usage:
user = Users.objects.get(ObjectId("x89831231313")) #get user by its id
user = Users.objects.get("x89831231313") #get user by its id
user = Users.objects.get(firstname="frank") #get one user by filter
user = Users.objects.get(age__gt=30) #get one user by filter
'''
from motorengine 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)
document_dict = await self.coll(alias).find_one(
filters,
projection=self._loaded_fields.to_query(self.__klass__),
)
if raw:
return document_dict
else:
# return Document object for furthur operation such as remove, update
if bool(document_dict) is False:
return None
else:
document = self.__klass__.from_son(
document_dict,
# if _loaded_fields is not empty then
# document is partly loaded
_is_partly_loaded=bool(self._loaded_fields),
# set projections for references (if any)
_reference_loaded_fields=self._reference_loaded_fields)
if (not lazy) or (not document.is_lazy):
await document.load_references()
return document
def test_gets_proper_query_when_embedded_document_in_many_levels(self):
query = Q(embedded__embedded2__test__lte="Test")
query_result = query.to_query(User)
expect(query_result).to_be_like(
{"embedded_document.embedded2.else": {
"$lte": "Test"
}})
def test_gets_proper_query_when_embedded_document(self):
query = Q(embedded__test__lte="Test")
query_result = query.to_query(User)
expect(query_result).to_be_like(
{"embedded_document.other": {
"$lte": "Test"
}})
def test_can_query_using_q(self):
self.create_test_users()
User.objects.find_all(callback=self.stop)
users = self.wait()
expect(users).to_length(3)
User.objects.filter(
Q(first_name="Bernardo")).find_all(callback=self.stop)
users = self.wait()
expect(users).to_length(1)
User.objects.filter(
Q(first_name="Bernardo")
| Q(first_name="Someone")).find_all(callback=self.stop)
users = self.wait()
expect(users).to_length(2)
def to_query(self):
from motorengine import Q
match_obj = {'$match': {}}
query = self.aggregation.queryset.get_query_from_filters(Q(**self.filters))
update(match_obj['$match'], query)
return match_obj
def test_can_query_using_q_for_list(self):
yield User.objects.create(
email="*****@*****.**",
first_name="Bernardo",
last_name="Heynemann",
embedded=EmbeddedDocument(test="test"),
numbers=[1, 2, 3],
)
user2 = yield User.objects.create(
email="*****@*****.**",
first_name="Someone",
last_name="Else",
embedded=EmbeddedDocument(test="test2"),
numbers=[4, 5, 6],
)
yield User.objects.create(
email="*****@*****.**",
first_name="John",
last_name="Doe",
embedded=EmbeddedDocument(test="test3"),
numbers=[7, 8, 9],
)
users = yield User.objects.filter(Q(numbers=[4])).find_all()
expect(users).to_length(1)
expect(users[0]._id).to_equal(user2._id)
users = yield User.objects.filter(Q(numbers=[5])).find_all()
expect(users).to_length(1)
expect(users[0]._id).to_equal(user2._id)
users = yield User.objects.filter(Q(numbers=[6])).find_all()
expect(users).to_length(1)
expect(users[0]._id).to_equal(user2._id)
users = yield User.objects.filter(Q(numbers=[4, 5, 6])).find_all()
expect(users).to_length(1)
expect(users[0]._id).to_equal(user2._id)
users = yield User.objects.filter(Q(numbers=[20])).find_all()
expect(users).to_length(0)
def test_can_query_using_not_in(self):
names = ["Someone", "John"]
query = ~Q(first_name__in=names)
query_result = query.to_query(User)
expect(query_result).to_be_like(
{'whatever': {
'$not': {
'$in': ['Someone', 'John']
}
}})
def distinct(self, key, filter=None, callback=None, alias=None, **kwargs):
from motorengine.query_builder.node import Q, QNode
if filter is not None and not isinstance(filter, QNode):
filter = Q(**filter)
if self._filters:
filter = self._filters if filter is None else self._filters & filter
if filter is not None:
filter = self.get_query_from_filters(filter)
self.coll(alias).distinct(
key, filter, callback=self.handle_distinct(callback), **kwargs
)
def test_can_create_new_instance_with_id(self):
user = EmployeeWithId(id="12345", emp_number="mynumber")
user.save(callback=self.stop)
result = self.wait()
expect(result._id).not_to_be_null()
expect(result.id).to_equal("12345")
for i in range(10):
EmployeeWithId.objects.filter(
Q(id="12345")).find_all(callback=self.stop)
result = self.wait()
emp = result[0]
#expect(emp._id).not_to_be_null()
expect(emp.id).to_equal("12345")
def filter_not(self, *arguments, **kwargs):
'''
Filters a queryset to negate all the filters passed in subsequent queries.
Usage::
User.objects.filter_not(first_name="Bernardo").filter_not(last_name="Bernardo").find_all(callback=handle_all)
# or
User.objects.filter_not(first_name="Bernardo", starting_year__gt=2010).find_all(callback=handle_all)
The available filter options are the same as used in MongoEngine.
'''
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 test_gets_proper_query_when_query_operator_used(self):
query = Q(first_name__lte="Test")
query_result = query.to_query(User)
expect(query_result).to_be_like({"whatever": {"$lte": "Test"}})
def test_gets_proper_type(self):
query = Q(first_name="Test")
expect(query).to_be_instance_of(Q)
query = Q(first_name="Test") | Q(first_name="Else")
expect(query).to_be_instance_of(QCombination)
def test_gets_proper_query(self):
query = Q(first_name="Test")
query_result = query.to_query(User)
expect(query_result).to_be_like({"whatever": "Test"})
def query(self, date, ins, branch):
branch = str(branch) if isinstance(branch, ObjectId) else branch
the_date = date
gmt8 = GMT8()
date = datetime.strptime(
datetime.now().strftime('%Y-%m-%d') if not date else date, '%Y-%m-%d')
counts = {}
sched_releases = {}
wr = yield Setting.objects.get(key='week_release')
week_release = tornado.escape.json_decode(wr.value)
week_release['date'] = datetime.strptime(
re.sub('\+\d{2}:\d{2}$', '', week_release['date']),
'%Y-%m-%d %H:%M:%S.%f')
updateWeek = week_release['date'] + timedelta(
days=-week_release['date'].weekday() + 6)
updateWeek = updateWeek.replace(tzinfo=gmt8)
days = {
'mon': 0,
'tue': 1,
'wed': 2,
'thu': 3,
'fri': 4,
'sat': 5,
'sun': 6
}
rtime = week_release['time'].split(':')
now = datetime.now(tz=gmt8)
dDay = now.weekday()
next_mon = now + timedelta(days=-dDay + 1, weeks=1)
next_mon = next_mon.replace(tzinfo=gmt8)
release_date = now + timedelta(days=-dDay + days[week_release['day']])
release_date = release_date.replace(hour=int(rtime[0]),
minute=int(rtime[1]),
second=0,
tzinfo=gmt8)
next_release = release_date + timedelta(weeks=1)
branch_filter = Q(branch=ObjectId(branch))
if branch == DEFAULT_BRANCH_ID:
branch_filter = Q(branch=ObjectId(branch)) | Q(branch__exists=False)
scheds = {}
week_days = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun', 'nmon']
for day in week_days:
sched_query = InstructorSchedule.objects.filter(date=date)
if branch:
sched_query.filter(branch_filter)
if ins:
qfilter = Q(instructor=ObjectId(ins)) | Q(
sub_instructor=ObjectId(ins))
sched_query.filter(qfilter).limit(4)
sched = yield sched_query.order_by(
'start', direction=ASCENDING).find_all(lazy=True)
if date.replace(tzinfo=gmt8) + timedelta(days=1) > now:
for s in sched:
sched_date = date.replace(hour=s.start.hour,
minute=s.start.minute,
second=0,
tzinfo=gmt8)
if (sched_date < now or sched_date > next_mon):
sched_releases[str(s._id)] = False
elif updateWeek < now and (now < release_date and date.replace(
tzinfo=gmt8) > release_date) or (
now > release_date
and date.replace(tzinfo=gmt8) > next_release):
sched_releases[str(s._id)] = False
else:
sched_releases[str(s._id)] = True
if sched_date > now or sched_releases[str(s._id)]:
waitlist_count = (yield BookedSchedule.objects.filter(
status='waitlisted', schedule=s._id).count())
book_count = 0
if waitlist_count == 0:
book_count = (yield BookedSchedule.objects.filter(
status='booked', schedule=s._id).count())
counts[str(s._id)] = {
'books': book_count,
'waitlist': waitlist_count
}
date += timedelta(days=1)
if branch:
default_branch = yield Branch.objects.get(ObjectId(branch))
for i, s in enumerate(sched):
if sched[i].branch is None:
sched[i].branch = default_branch
scheds[day] = sched
scheds['counts'] = counts
scheds['releases'] = sched_releases
scheds['now'] = str(now)
scheds['date'] = the_date
scheds['branch_id'] = branch
return scheds
def test_gets_proper_query_when_list_field(self):
query = Q(numbers=[10])
query_result = query.to_query(User)
expect(query_result).to_be_like({"numbers": {"$all": [10]}})