def build_query(self, *args, **kwargs):
""" Returns django.db.models.Q object to be used for the objects retrival.
Arguments:
- args: unnamed URL arguments
- kwargs: named URL arguments
If a URL passes any arguments to the view being the QueryMixin subclass
build_query manages the arguments and provides the Q object that will be
used for the objects retrival with filter/get queryset methods.
Technically, neither args nor kwargs have to be provided, however the default
behaviour is to map all kwargs as the query constructors so that if this
method is not overriden only kwargs keys being model fields are valid.
If positional args are provided, the last one argument is understood
as the primary key. However this usage should be considered
deperecated, and will be removed in a future version.
"""
tmp = dict(kwargs)
# If the URLconf includes a .(?P<format>\w+) pattern to match against
# a .json, .xml suffix, then drop the 'format' kwarg before
# constructing the query.
if BaseRenderer._FORMAT_QUERY_PARAM in tmp:
del tmp[BaseRenderer._FORMAT_QUERY_PARAM]
if args:
# If we have any no kwargs then assume the last arg represents the
# primrary key. Otherwise assume the kwargs uniquely identify the
# model.
tmp.update({'pk': args[-1]})
return Q(**tmp)
def __init__(self, entity, *args, **kwargs):
# super(CampaignAddMLForm, self).__init__(*args, **kwargs)
super().__init__(*args, **kwargs)
self.campaign = entity
# self.fields['mailing_lists'].q_filter = {'~id__in': list(entity.mailing_lists.values_list('id', flat=True))}
self.fields['mailing_lists'].q_filter = \
~Q(id__in=list(entity.mailing_lists.values_list('id', flat=True)))
def merge_many_to_many(items, binder, queryset, single_result=False,
id_path="id"):
from django.db.models.query import Q, QAnd, QOr
from operator import itemgetter, attrgetter
from itertools import repeat, groupby
# Generate the Q objects and the (type_id, id)-ordered item list
id_path_q = id_path + "__in"
item_ids = map(attrgetter("id"), items)
q = Q(**{ id_path_q : item_ids })
item_set = dict(zip(item_ids, items))
results = queryset.filter(q).order_by(id_path + "_id")[:]
id_path_attr = id_path + "_id"
result_set = {}
item_group = groupby(results, attrgetter(id_path_attr)) #lambda result: result.id)
for item_id, item_iter in item_group:
result_set[item_id] = list(item_iter)
#print repr((results))
#print repr((result_set))
for item_id, item in item_set.items():
item_results = result_set.get(item_id, [])
binder(item, item_results)
return
def test_render_qfilter02(self):
"Q instance."
widget = EntitySelector(content_type=13)
name = 'my_field'
value = '2'
render_dom = assert_and_parse_html(
self,
widget.render(name, value, attrs={'qfilter': Q(name='foobar')}),
user_msg=None,
msg='Widget render is not valid !',
)
qfilter_attr = self.assertQFilter(render_dom, {'val': [['name', 'foobar']], 'op': 'AND'})
html = \
'''<span class="ui-creme-widget widget-auto ui-creme-entityselector" widget="ui-creme-entityselector"
labelURL="{text_url}" label="{label}" popupURL="{url}" popupSelection="single"
qfilter="{q_filter}">
<input name="{name}" type="hidden" class="ui-creme-input ui-creme-entityselector" value="{value}"/>
<button type="button">{label}</button>
</span>'''.format(
name=name,
value=value,
label=_('Select…'),
text_url=TemplateURLBuilder(entity_id=(TemplateURLBuilder.Int, '${id}'))
.resolve('creme_core__entity_as_json'),
url=reverse('creme_core__listview_popup') + '?ct_id=13&selection=${selection}&q_filter=${qfilter}',
q_filter=escape(qfilter_attr),
)
self.assertDOMEqual(assert_and_parse_html(self, html, None, 'Expected HTML is not valid !'), render_dom)
def teachers(self, QObject=False):
Q_teachers = Q(remoteprofile__program=self.program)
if QObject:
return {'teacher_remoteprofile': self.getQForUser(Q_teachers)}
teachers = ESPUser.objects.filter(Q_teachers).distinct()
return {'teacher_remoteprofile': teachers}
def students(self, QObject = False):
result = {}
Q_applied = Q(studentprogramapp__program=self.program)
result['applied'] = Q_applied if QObject else ESPUser.objects.filter(Q_applied)
return result
def students(self, QObject=False):
q_phasezero = Q(phasezerorecord__program=self.program)
if QObject:
return {'phasezero': q_phasezero}
return {'phasezero': ESPUser.objects.filter(q_phasezero).distinct()}
def _django_search(query_dict):
form = ProductFilterForm(data=query_dict)
if len(query_dict.keys()) > 1:
if form.is_valid():
data = form.cleaned_data
for key, value in data.items():
if not value:
del data[key]
if 'id__in' in query_dict:
data['id__in'] = query_dict['id__in'].split(',')
if 'has_expired' in query_dict:
data['expiry__lt'] = datetime.now()
if 'is_valid' in query_dict:
data['expiry__gte'] = datetime.now()
Q_obj = Q()
Q_obj.connector = data.pop("connector")
Q_obj.children = data.items()
product_list = Product.objects.filter(Q_obj)
num_found = product_list.count()
else:
product_list = Product.objects.none()
num_found = 0
else:
product_list = Product.objects.none()
num_found = 0
return product_list, num_found
def tags(self, related_to=None):
""" Returns a QuerySet of tagging.models.Tag objects
related to members of the QuerySet, optionally limited
to either those also related to the tag, or those which
are named (with related_to). """
if related_to is None:
return tags.Tag.objects.filter(id__in=(
t.id for t in tags.Tag.objects.usage_for_queryset(self.all())))
else:
return tags.Tag.objects.filter(
Q(id__in=(t.id for t in tags.Tag.objects.related_for_model(
related_to, self.model)))
& Q(id__in=(
t.id
for t in tags.Tag.objects.usage_for_queryset(self.all()))))
def students(self, QObject = False):
QObj = Q(transfer__line_item=self.line_item_type())
if QObject:
return {'donation': QObj}
else:
return {'donation': ESPUser.objects.filter(QObj).distinct()}
def admin_morph(self, request, tl, one, two, module, extra, prog):
""" This function will allow someone to morph into a user for testing purposes. """
# If there's no 'extra' component to the URL, return the options page.
if extra is None or extra == '':
context = {'module': self}
return render_to_response(self.baseDir()+'options.html', request, (prog, tl), context)
# Default query is to get program participants
query = self.program.students_union(True) | self.program.teachers_union(True) | self.program.volunteers_union(True)
# List all of the useful queries we can think of. If we had some autosave (pickle type)
# feature, that could be really cool.
saved_queries = { 'student': self.program.students_union(True),
'teacher': self.program.teachers_union(True),
'volunteer': self.program.volunteers_union(True),
'program': self.program.students_union(True) | self.program.teachers_union(True) | self.program.volunteers_union(True),
'all': Q()
}
if extra in saved_queries:
query = saved_queries[extra]
user, found = search_for_user(request, ESPUser.objects.filter(query))
if not found:
return user
request.user.switch_to_user(request,
user,
'/manage/%s/admin_morph/' % prog.getUrlBase(),
'Managing %s' % self.program.niceName(),
False)
return HttpResponseRedirect('/')
def run(self, username, minutes_ago=5, **kwargs):
try:
user = UserProfile.objects.get(username=username)
except:
return False
try:
user_chat = Chat.objects.get(user=user)
except:
return False
freinds = user_chat.tabs_to.split(',')
logger = ProcessMessage.get_logger()
logger.info('freinds %s' % (freinds))
since = user_chat.date - datetime.timedelta(minutes=minutes_ago)
logger.info('since %s' % (since))
for friend in freinds:
try:
friend_obj = UserProfile.objects.get(username=friend)
except:
continue
messages = Messaging.objects.filter(Q(user=user_chat.user, user_to=friend_obj) | Q(user=friend_obj, user_to=user_chat.user)) \
.filer(date__gte=since) \
.order_by('date')
logger.info('messages %s' % (messages.count()))
r.publish(user, serializers.serialize("json", messages))
return True
def _get_q4model(self, model, keywords):
if not hasattr(model, "SearchMeta"):
raise ModelIsNotSearchable, unicode(
_('Please define class SearchMeta'))
meta_attr = getattr(model, "SearchMeta")
if not hasattr(meta_attr, "fields"):
raise ModelIsNotSearchable, unicode(
_('Please define SearchMeta.fields = []'))
fields = getattr(meta_attr, "fields")
keyword_qs = []
for keyword in keywords:
qdict = dict()
qlist = []
field_qs = map(
lambda field: self._get_q4tuple(field + "__icontains", keyword
), fields)
keyword_q = reduce(lambda x, y: x | y, field_qs)
keyword_qs.append(keyword_q)
qfin = reduce(lambda x, y: x & y, keyword_qs)
if hasattr(meta_attr, "filter_func"):
fq = getattr(meta_attr, "filter_func")()
qfin = qfin & fq
return Q(qfin)
def rollback(request, pk): # 回滚
issue = Issue.objects.filter(pk=pk).first()
host_issue = issue.hostissue_set.filter(Q(status="2") | Q(status="3"))
print(host_issue)
# server_res = True
server_res = update_host(host_issue, issue, issue.type, 0)
if server_res:
issue.status = "6"
issue.save()
host_issue.update(status="6")
return JsonResponse({'status': 0, 'msg': '回滚成功'})
else:
issue.status = "7"
issue.save()
host_issue.update(status="7")
return JsonResponse({'status': 1, 'msg': '回滚失败'})
def query(self) -> Q:
"""
Gets the Q query object
:return: The Q query object
"""
args = self.get_args("latest_price__paper_value")
return Q(**args)
def volunteers(self, QObject=False):
requests = self.program.volunteerrequest_set.all()
queries = {
'volunteer_all': Q(volunteeroffer__request__program=self.program)
}
for req in requests:
key = 'volunteer_%d' % req.id
queries[key] = Q(volunteeroffer__request=req)
result = {}
for key in queries:
if QObject:
result[key] = queries[key]
else:
result[key] = ESPUser.objects.filter(queries[key]).distinct()
return result
def join(self, model_or_queryset, *filter_q, **filter_kw):
"""Join this CTE to the given model or queryset
This CTE will be refernced by the returned queryset, but the
corresponding `WITH ...` statement will not be prepended to the
queryset's SQL output; use `<CTEQuerySet>.with_cte(cte)` to
achieve that outcome.
:param model_or_queryset: Model class or queryset to which the
CTE should be joined.
:param *filter_q: Join condition Q expressions (optional).
:param **filter_kw: Join conditions. All LHS fields (kwarg keys)
are assumed to reference `model_or_queryset` fields. Use
`cte.col.name` on the RHS to recursively reference CTE query
columns. For example: `cte.join(Book, id=cte.col.id)`
:returns: A queryset with the given model or queryset joined to
this CTE.
"""
if isinstance(model_or_queryset, QuerySet):
queryset = model_or_queryset.all()
else:
queryset = model_or_queryset.objects.all()
join_type = filter_kw.pop("_join_type", INNER)
query = queryset.query
# based on Query.add_q: add necessary joins to query, but no filter
q_object = Q(*filter_q, **filter_kw)
map = query.alias_map
existing_inner = set(a for a in map if map[a].join_type == INNER)
on_clause, _ = query._add_q(q_object, query.used_aliases)
query.demote_joins(existing_inner)
parent = query.get_initial_alias()
query.join(QJoin(parent, self.name, self.name, on_clause, join_type))
return queryset
def students_status(self, request, tl, one, two, module, extra, prog):
resp = HttpResponse(mimetype='application/json')
grade_query = """
SELECT (12 + %d - "users_studentinfo"."graduation_year")
FROM "users_studentinfo", "program_registrationprofile"
WHERE
"program_registrationprofile"."most_recent_profile" = true
AND "program_registrationprofile"."student_info_id" = "users_studentinfo"."id"
AND "users_studentinfo"."user_id" = "auth_user"."id"
ORDER BY program_registrationprofile.id DESC
LIMIT 1
""" % ESPUser.current_schoolyear()
# Try to ensure we don't miss anyone
students_dict = self.program.students(QObjects=True)
student_types = [
'student_profile'
] # You could add more list names here, but it would get very slow.
students_Q = Q()
for student_type in student_types:
students_Q = students_Q | students_dict[student_type]
students = ESPUser.objects.filter(students_Q).distinct()
data = students.extra({
'grade': grade_query
}).values_list('id', 'last_name', 'first_name', 'grade').distinct()
simplejson.dump(list(data), resp)
return resp
def executed(request):
condition = request.GET.get('name', '')
q = Q()
q.connector = 'OR'
q.children.append(('user__username__contains', condition))
q.children.append(('command__contains', condition))
q.children.append(('host__contains', condition))
if request.account.isAdmin == '0':
form_obj = Command.objects.filter(q)
else:
form_obj = Command.objects.filter(user=request.account).filter(q)
li = []
for item in form_obj:
item.host = json.loads(item.host)
item.command = item.command.split('\n')
print(item.result)
item.result = [v for v in json.loads(item.result).values() if v]
print(item.result)
# json.loads(item.result.replace("'", '"'))
li.append(item)
pager = Pagination(request.GET.get('page', '1'), form_obj.count(),
request.GET.copy(), 10)
return TemplateResponse(
request, 'command_list.html', {
'form_obj': li[pager.start:pager.end],
'page_html': pager.page_html,
'page_type': '执行命令历史'
})
def test_spec_with_filter(self):
self.detail_view.serialization_spec = [
{
'school': [
'name', {
'teacher_set': Filtered(Q(name__icontains='cat'),
['name'])
}
]
},
]
with self.assertNumQueries(2):
response = self.detail_view.retrieve(self.request)
self.assertJsonEqual(
response.data, {
"school": {
"name": "Kitteh High",
"teacher_set": [
{
"name": "Mr Cat"
},
]
}
})
def _get_next_or_previous_by_FIELD(self, field, is_next, **kwargs):
if not self.pk:
raise ValueError(
"get_next/get_previous cannot be used on unsaved objects.")
op = is_next and 'gt' or 'lt'
order = not is_next and '-' or ''
param = smart_str(getattr(self, field.attname))
q = Q(**{'%s__%s' % (field.name, op): param})
q = q | Q(**{field.name: param, 'pk__%s' % op: self.pk})
qs = self.__class__._default_manager.using(self._state.db).filter(
**kwargs).filter(q).order_by('%s%s' % (order, field.name),
'%spk' % order)
try:
return qs[0]
except IndexError:
raise self.DoesNotExist("%s matching query does not exist." %
self.__class__._meta.object_name)
def resolve_search_list(self, info, query, **kwargs):
videos = models.Video.objects\
.filter(
Q(title__icontains=query) |\
Q(description__icontains=query),
is_published=True
).order_by('-published_at')
speakers = models.Speaker.objects\
.annotate(video_amount=Count(Case(When(videospeaker__video__is_published=True, then=1))))\
.filter(Q(name__icontains=query))
sources = models.Source.objects\
.annotate(video_amount=Count(Case(When(video__is_published=True, then=1))))\
.filter(Q(name__icontains=query))
return SearchList(videos=videos, speakers=speakers, sources=sources)
def __init__(self, entity, *args, **kwargs):
super().__init__(*args, **kwargs)
self.billing_document = entity
existing = Relation.objects.filter(
subject_entity=entity.id,
type=constants.REL_OBJ_CREDIT_NOTE_APPLIED)
# TODO waiting for automated change of status when a credit note is out of date by looking to expiration date
# TODO Add another filter today <= expiration_date ??
q_filter = ~Q(pk__in=[rel.object_entity_id for rel in existing]) & \
Q(currency=entity.currency.id,
# status=CreditNoteStatus.objects.get(pk=ISSUED_CREDIT_NOTE).id, # TODO workflow status
relations__type=constants.REL_SUB_BILL_RECEIVED,
relations__object_entity=entity.get_real_entity().get_target().id,
)
self.fields['credit_notes'].q_filter = q_filter
def students(self, QObject=False):
Q_students = Q(studentapplication__program=self.program)
Q_students_complete = Q(studentapplication__done=True)
if QObject:
return {
'studentapps_complete': Q_students & Q_students_complete,
'studentapps': Q_students
}
else:
return {
'studentapps_complete':
ESPUser.objects.filter(Q_students & Q_students_complete),
'studentapps':
ESPUser.objects.filter(Q_students)
}
def toggle_completed(self, request: 'HttpRequest', queryset: 'QuerySet'):
"""
Toggle the status of the selected series.
:param request: The original request.
:param queryset: The original queryset.
"""
queryset.update(completed=Q(completed=False))
def students(self, QObject=False):
q = Q(studentregistration__section__parent_class__parent_program=self.
program) & nest_Q(StudentRegistration.is_valid_qobject(),
'studentregistration')
if QObject:
return {'lotteried_students': q}
else:
return {'lotteried_students': ESPUser.objects.filter(q).distinct()}
def test_text_input(self):
text_input = query_builder.TextInput("a_db_field")
self.assertEqual(text_input.spec(), {
'reactClass': 'TextInput',
'name': 'a db field'
})
self.assertEqual(str(text_input.as_q("foo bar baz")),
str(Q(a_db_field="foo bar baz")))
def update_messages_for_topic_edit(message: Message, propagate_mode: str,
orig_topic_name: str,
topic_name: Optional[str],
new_stream: Optional[Stream],
edit_history_event: Dict[str, Any],
last_edit_time: datetime) -> List[Message]:
propagate_query = Q(recipient=message.recipient,
subject__iexact=orig_topic_name)
if propagate_mode == 'change_all':
propagate_query = propagate_query & ~Q(id=message.id)
if propagate_mode == 'change_later':
propagate_query = propagate_query & Q(id__gt=message.id)
messages = Message.objects.filter(propagate_query).select_related()
update_fields = ['edit_history', 'last_edit_time']
# Evaluate the query before running the update
messages_list = list(messages)
# The cached ORM objects are not changed by the upcoming
# messages.update(), and the remote cache update (done by the
# caller) requires the new value, so we manually update the
# objects in addition to sending a bulk query to the database.
if new_stream is not None:
update_fields.append("recipient")
for m in messages_list:
m.recipient = new_stream.recipient
if topic_name is not None:
update_fields.append("subject")
for m in messages_list:
m.set_topic_name(topic_name)
for message in messages_list:
message.last_edit_time = last_edit_time
if message.edit_history is not None:
edit_history = orjson.loads(message.edit_history)
edit_history.insert(0, edit_history_event)
else:
edit_history = [edit_history_event]
message.edit_history = orjson.dumps(edit_history).decode()
Message.objects.bulk_update(messages_list, update_fields)
return messages_list
def query(self) -> Q:
"""
Gets the Q query object
:return: The Q query object
"""
args = (self.get_args("card__colour_identity_count") if self.identity
else self.get_args("card__faces__colour_count"))
return Q(**args)
def toggle_final(self, request: 'HttpRequest', queryset: 'QuerySet'):
"""
Toggle the status of the selected chapters.
:param request: The original request.
:param queryset: The original queryset.
"""
queryset.update(final=Q(final=False))
