def f(self):
import django_teams.models
#sys.stdout.write("In overridemanager for "+repr(self.model)+"\n")
#sys.stdout.write(repr(dir(self)))
#sys.stdout.write("\n")
#sys.stdout.flush()
if django_teams.models.CurrentUser == None:
return QuerySet(model=self.model, using=self._db)
else:
# Get a list of objects on this model that the user has access too
content_type = ContentType.objects.get_for_model(self.model)
pk_list = None
if django_teams.models.CurrentTeam != None:
# If they are only invited to current team, raise an error
if TeamStatus.objects.get(
team=django_teams.models.CurrentTeam,
user=django_teams.models.CurrentUser).role < 10:
raise ObjectDoesNotExist()
pk_list = Ownership.objects.values_list(
"object_id",
flat=True).filter(content_type=content_type,
team=django_teams.models.CurrentTeam)
else:
pk_list = Ownership.objects.values_list(
"object_id", flat=True).filter(
content_type=content_type,
team__in=django_teams.models.CurrentUser.team_set.
filter(teamstatus__role__gte=10))
return QuerySet(model=self.model,
using=self._db).filter(pk__in=pk_list)
def get_query_set(self):
attrs = []
cls = self.model.__class__
if not hasattr(cls, '_meta'):
return QuerySet(self.model, using=self._db)
for r in cls._meta.get_all_related_objects():
if not issubclass(r.model, cls) or\
not isinstance(r.field, models.OneToOneField):
continue
attrs.append(r.get_accessor_name())
return QuerySet(self.model, using=self._db).select_related(*attrs)
def event(request):
events = Event.objects.filter(is_approved2=True,
is_approved1=True,
event_type='I')
if is_logged_in(request):
user = None
user_id = request.session['user']['login_id']
if request.session['user']['type_user'] == 'student':
user = Student.objects.filter(id=user_id)[0]
else:
user = Staff.objects.filter(id=user_id)[0]
dpt_allowed = Dept_Allowed.objects.filter(dept_id=user.dept,
is_approved=True)
dept_events = QuerySet()
if dpt_allowed:
eids = []
for d in dpt_allowed:
eids.append(d.event_id.id)
print("eids", eids)
dept_events = Event.objects.filter(id__in=eids)
if dept_events:
events = events.union(dept_events)
return render(request, 'vesit/events.html', {'events': events})
def render(self, context):
logging.debug('blaat')
logging.debug(self.object_list)
object_list = self.object_list.resolve(context)
object_current = self.object_current.resolve(context)
from django.db.models.query import QuerySet
logging.debug(object_list)
if type(QuerySet()) == type(object_list):
# This is efficient, but very experimental
if len(object_list.query.order_by) == 1:
if object_list.query.order_by[0][0] == '-':
date_field = object_list.query.order_by[0][1:]
prev_getter = getattr(object_current,
'get_previous_by_%s' % date_field,
None)
if prev_getter:
object_previous = prev_getter()
else:
date_field = object_list.query.order_by[0]
prev_getter = getattr(object_current,
'get_next_by_%s' % date_field, None)
if prev_getter:
object_previous = prev_getter()
previous_id = get_previous(
object_list.values_list('id', flat=True), object_current.id)
object_previous = object_list.get(id=previous_id)
else:
object_previous = get_previous(list(object_list), object_current)
context[self.previous_name] = object_previous
return ''
def __get__(self, instance, instance_type=None):
if instance is None:
return self
cache_name = self.field.get_cache_name()
try:
return getattr(instance, cache_name)
except AttributeError:
val = getattr(instance, self.field.attname)
if val is None:
# If NULL is an allowed value, return it.
if self.field.null:
return None
raise self.field.rel.to.DoesNotExist
other_field = self.field.rel.get_related_field()
if other_field.rel:
params = {'%s__pk' % self.field.rel.field_name: val}
else:
params = {'%s__exact' % self.field.rel.field_name: val}
# If the related manager indicates that it should be used for
# related fields, respect that.
rel_mgr = self.field.rel.to._default_manager
if getattr(rel_mgr, 'use_for_related_fields', False):
rel_obj = rel_mgr.get(**params)
else:
rel_obj = QuerySet(self.field.rel.to).get(**params)
setattr(instance, cache_name, rel_obj)
return rel_obj
def get_searched_queryset(self, qs):
model = self.model
term = self.GET["term"]
try:
term = model.autocomplete_term_adjust(term)
except AttributeError:
pass
try:
search_fields = model.autocomplete_search_fields()
except AttributeError:
try:
search_fields = AUTOCOMPLETE_SEARCH_FIELDS[
model._meta.app_label][model._meta.model_name]
except KeyError:
search_fields = ()
if search_fields:
for word in term.split():
search = [
models.Q(**{smart_text(item): smart_text(word)})
for item in search_fields
]
search_qs = QuerySet(model)
search_qs.query.select_related = qs.query.select_related
search_qs = search_qs.filter(reduce(operator.or_, search))
qs &= search_qs
else:
qs = model.objects.none()
return qs
def autocomplete_lookup(request):
if not (request.user.is_active and request.user.is_staff):
return HttpResponseForbidden('<h1>Permission denied</h1>')
data = []
if request.method == 'GET':
if request.GET.has_key('term') and request.GET.has_key('app_label') and request.GET.has_key('model_name'):
term = request.GET.get("term")
app_label = request.GET.get('app_label')
model_name = request.GET.get('model_name')
model = models.get_model(app_label, model_name)
filters = {}
# FILTER
if request.GET.get('query_string', None):
for item in request.GET.get('query_string').split("&"):
if item.split("=")[0] != "t":
filters[smart_str(item.split("=")[0])]=smart_str(item.split("=")[1])
# SEARCH
qs = model._default_manager.all()
for bit in term.split():
search = [models.Q(**{smart_str(item):smart_str(bit)}) for item in model.autocomplete_search_fields()]
search_qs = QuerySet(model)
search_qs.dup_select_related(qs)
search_qs = search_qs.filter(reduce(operator.or_, search))
qs = qs & search_qs
data = [{"value":f.pk,"label":u'%s' % get_label(f)} for f in qs[:10]]
label = ungettext(
'%(counter)s result',
'%(counter)s results',
len(data)) % {
'counter': len(data),
}
#data.insert(0, {"value":None,"label":label})
return HttpResponse(simplejson.dumps(data), mimetype='application/javascript')
data = [{"value":None,"label":_("Server error")}]
return HttpResponse(simplejson.dumps(data), mimetype='application/javascript')
def get_recommended_jobs(self, user):
user_skills = user.skills.all()
recommended_jobs = QuerySet(model=Job)
for skill in user_skills:
recommended_jobs = recommended_jobs | skill.jobs.all()
recommended_jobs = recommended_jobs.distinct()
return recommended_jobs
def change_view(self, request, object_id, form_url='', extra_context=None):
"""Premept 404s caused by changing the site on the change form page."""
extra_context = extra_context or {}
try:
response = super(TranslatableMixin,
self).change_view(request,
object_id,
form_url=form_url,
extra_context=extra_context)
except Http404 as e:
# See if the object can be found on another site/language
try:
object_id = self.model._meta.pk.to_python(object_id)
found = QuerySet(self.model).get(pk=object_id)
except (self.model.DoesNotExist, ValidationError, ValueError):
raise e
else:
# Find the object with the same slug on this site.
try:
expected = self.get_queryset(request).get(slug=found.slug)
except self.model.DoesNotExist:
raise e
response = redirect(admin_urlname(self.model._meta, 'change'),
expected.pk)
return response
def get_queryset(self):
from django.utils.encoding import smart_text
from functools import reduce
from django.db.models.query import QuerySet
import operator
from django.db import models
if not self.request.user.is_authenticated():
return Director.objects.none()
qs = Director.objects.all()
if self.q:
search_fields = ("id__iexact", "nombre__icontains",
"apellido__icontains")
for word in self.q.split():
search = [
models.Q(**{smart_text(item): smart_text(word)})
for item in search_fields
]
search_qs = QuerySet(Director)
search_qs.query.select_related = qs.query.select_related
search_qs = search_qs.filter(reduce(operator.or_, search))
qs &= search_qs
return qs
def searchTutor(request):
# Retrieve search critera from http request
# Search critera in standardurl parameters search/search?keyword=k&date=1997&....
keyword = request.GET.get('keyword', '')
# Define containers
context = {}
tutorList = QuerySet()
# Retrieving tutor informations
if keyword == '':
# Default search return all search results
tutorList = Tutor.listAll()
else:
# Search tutor names with provided search critera
# Separate mutiple keywords into array by space delimiter
keywordArray = keyword.split()
# Get tutors by provided queries
tutorList = Tutor.filterByName(keywordArray)
# Build context for template rendering
context['tutorList'] = tutorList
# Respond search result to client
if not tutorList:
# Empty search result
return HttpResponse("No match result is found")
else:
# Render context into template
results = ""
for obj in tutorList:
#results += str(obj) + "<br>"
results += str(obj) + "<br>"
return HttpResponse(results)
def test_sc_homepage_summary_complete_with_archived_SAs(
logged_in_client, test_user):
# Arrange
active_sa = SupplyChainFactory(
name="Medical",
gov_department=test_user.gov_department,
)
sc = SupplyChainFactory(
name="carbon",
gov_department=test_user.gov_department,
)
sa = StrategicActionFactory(supply_chain=active_sa)
StrategicActionFactory.create_batch(3,
supply_chain=sc,
is_archived=True,
archived_reason="Reason")
StrategicActionUpdateFactory()
dummy_qs = QuerySet(model=StrategicActionUpdate)
# Act
with mock.patch(
"supply_chains.models.SupplyChainQuerySet.submitted_since",
return_value=dummy_qs,
):
resp = logged_in_client.get(reverse("sc-home"))
# Assert
assert resp.context["update_complete"]
assert resp.context["num_in_prog_supply_chains"] == 0
assert len(resp.context["supply_chains"]) == 2
def get_queryset(self):
usr = self.request.user
self.group = get_object_or_404(SuaGroup, pk=self.kwargs['pk'])
appeals = QuerySet()
if usr.is_superuser or self.group.group in usr.groups.all():
appeals = Appeal.objects.filter(gsua__group=self.group)
return appeals
def search(self, request):
"""
Searches in the fields of the given related model and returns the
result as a simple string to be used by the jQuery Autocomplete plugin
"""
query = request.GET.get('q', None)
app_label = request.GET.get('app_label', None)
model_name = request.GET.get('model_name', None)
search_fields = request.GET.get('search_fields', None)
if search_fields and app_label and model_name and query:
def construct_search(field_name):
# use different lookup methods depending on the notation
if field_name.startswith('^'):
return "%s__istartswith" % field_name[1:]
elif field_name.startswith('='):
return "%s__iexact" % field_name[1:]
elif field_name.startswith('@'):
return "%s__search" % field_name[1:]
else:
return "%s__icontains" % field_name
model = models.get_model(app_label, model_name)
qs = model._default_manager.all()
for bit in query.split():
or_queries = [models.Q(**{construct_search(
smart_str(field_name)): smart_str(bit)})
for field_name in search_fields.split(',')]
other_qs = QuerySet(model)
other_qs.dup_select_related(qs)
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
qs = qs & other_qs
data = ''.join([u'%s|%s\n' % (f.__unicode__(), f.pk) for f in qs])
return HttpResponse(data)
return HttpResponseNotFound()
def leaf_filter(self, query):
'''
Should not be called directly, use filter()
Executes a query over leaf instances of MapObj
allows for some complex / cross model queries
ex:
q1 = Q(name__icontains='commons')
q2 = Q(abbreviation__icontains='map')
MapObj.objects.filter(q1|q2)
returns:
[<Group: Ferrell Commons>, <Building: Libra Commons>, <Building: Math & Physics>, ...]
'''
# grab all the models that extend MapObj
if not MapQuerySet.campus_models:
MapQuerySet.campus_models = []
for ct in ContentType.objects.filter(app_label="campus"):
model = models.get_model("campus", ct.model)
if issubclass(model, campus.models.MapObj):
MapQuerySet.campus_models.append(model)
# return queryset containing MapObj's
mob_query = Q(pk="~~~ no results ~~~")
for m in self.campus_models:
if m == campus.models.MapObj: continue
try:
qs = QuerySet(m)
results = qs.filter(query)
for o in results:
mob_query = mob_query | Q(id=o.mapobj_ptr_id)
except FieldError:
continue
return mob_query
def test_get_combinator_sql_empty_queryset_raises_exception(self):
"""
Tries sql generator with empty queryset.
"""
compiler = SQLCompiler(QuerySet().query, self.connection, "default")
with self.assertRaises(EmptyResultSet):
compiler.get_combinator_sql("union", False)
def powerOn(request):
response_data = {}
username = request.POST["auth_username"]
passowrd = request.POST["auth_password"]
user = authenticate(username = username, password = passowrd)
if user is not None:
id_brand = SpareBrandList.objects.get(brand_en = "Lenovo")
if request.user.username == "surecoteam":
# brand_en = Lenovo
query = StandardData.objects.filter(id_brand = id_brand).query
elif request.user.username == "dcitsteam":
# brand_en = Dell and so on
query = StandardData.objects.exclude(id_brand = id_brand).query
else:
query = StandardData.objects.all().query
query.group_by = ['std_batch','id_brand_id']
batch_brand = QuerySet(query = query, model = StandardData)
cur_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time()))
response_data = {"ret_code":200,"ret_info":"加电成功！"}
for item in batch_brand:
try:
ob_power_on = PowerOnTime(pt_batch = item.std_batch, id_brand = item.id_brand,
pt_time = cur_time, id_user = request.user)
ob_power_on.save()
except Exception,ex:
response_data = {"ret_code":500,"ret_info":"加电成功！"}
continue
def clone_model(self, model, dbsource, dbdest, num_instances,
appname, models, num_models, stats, verbosity):
q = model.objects.using(dbsource).all()
if verbosity > 0:
print("- Model", model.__name__, ":", q.count(), "objects found")
num_model_instances = 0
if inspect.has_m2m(model) is False:
numi = q.count()
if numi > 0:
print("Bulk creating", str(numi), "instances for model",
model.__name__, "...")
try:
qs = QuerySet(model=model, query=q, using=dbdest)
self.bulk_create(q, using=dbdest, qs=qs)
num_instances += numi
num_model_instances += numi
except Exception as e:
err.new(e, self.clone_model,
"Can not bulk create model " + model.__name__)
return
else:
for instance in q:
print(num_instances, appname, "-",
model.__name__, num_model_instances)
num_instances += 1
num_model_instances += 1
try:
self._save_instance(model, instance, dbdest)
except Exception as e:
err.new(e, self.clone_model,
"Can not clone model " + model.__name__)
return
stats[appname]["num_models"] = len(models[appname])
stats[appname][model.__name__] = num_model_instances
return stats, num_instances
def render_change_form(self,
request,
context,
add=False,
change=False,
form_url='',
obj=None):
if change and obj.site_id != settings.SITE_ID:
# Grab the default language version of the object
try:
default = QuerySet(obj.__class__).filter(
slug=obj.slug, site=settings.SITE_ID)[0]
except IndexError:
context['default_language_url'] = None
else:
with override(settings.LANGUAGE_CODE):
meta = default.__class__._meta
context['default_language_url'] = reverse(
admin_urlname(meta, 'change'), args=(default.id, ))
context['tranlsated_fields'] = self.tranlsated_fields
response = super(TranslatableMixin,
self).render_change_form(request,
context,
add=add,
change=change,
form_url=form_url,
obj=obj)
if change and obj.site_id != settings.SITE_ID:
# Hijack the delayed rendering to replace the change form while
# extending from the original template
if not response.is_rendered:
current_template = select_template(response.template_name).name
response.context_data['base_template'] = current_template
response.template_name = 'translations/admin/change_form.html'
return response
def _folder(self, related, filters, option='m', order_by=None):
"""Base code, in common to the folders."""
qs = self.all() if option == OPTION_MESSAGES else QuerySet(self.model, PostmanQuery(self.model), using=self._db)
if related:
qs = qs.select_related(*related)
if order_by:
qs = qs.order_by(order_by)
if isinstance(filters, (list, tuple)):
lookups = models.Q()
for filter in filters:
lookups |= models.Q(**filter)
else:
lookups = models.Q(**filters)
if option == OPTION_MESSAGES: # This is for message-based views.
# qs = qs.extra(select={'count': 'SELECT 1'})
return qs.filter(lookups)
# Adding a 'count' attribute, to be similar to the by-conversation case,
# should not be necessary. Otherwise add:
# .extra(select={'count': 'SELECT 1'})
else:
"""Ok. We were having problems with the commented block out above.
We kept getting can't get PM.count, which was only a problem here.
We were desperate, and commented all of this stuff out.
It works now, but if we have problems later, it's probably here."""
# qs = qs.extra(select={'count': 'count()'.format(qs.query.pm_alias_prefix)})
qs.query.pm_set_extra(table=(
self.filter(lookups, thread_id__isnull=True).extra(select={'count': 0})\
.values_list('id', 'count').order_by(),
self.filter(lookups, thread_id__isnull=False).values('thread').annotate(id=models.Max('pk'), count=models.Count('pk'))\
.values_list('id', 'count').order_by(),
))
return qs.filter(**filters) #magic fix
def detailed_product(request, id, slug):
query = request.GET.get('query')
list = request.session["selected_customer"]
c = Customer.objects.get(pk=list[0])
user = request.user
category = Category.objects.all()
product = Product.objects.get(pk=id)
images = Images.objects.filter(product_id=id)
comments = Comment.objects.filter(product_id=id, status='True')
context = {
'product': product,
'category': category,
'images': images,
'comments': comments,
"selected_c": c,
}
if product.variant != "None": # Product have variants
if request.method == 'POST': #if we select color
variant_id = request.POST.get('variantid')
variant = Variants.objects.get(
id=variant_id) #selected product by click color radio
colors = Variants.objects.raw(
'SELECT * FROM product_variants WHERE product_id=%s GROUP BY color_id',
[id])
#colors = Variants.objects.filter(product_id=id,size_id=variant.size_id )
sizes = Variants.objects.filter(product_id=id,
color_id=variant.color_id)
query += variant.title + ' Size:' + str(
variant.size) + ' Color:' + str(variant.color)
else:
variants = Variants.objects.filter(product_id=id)
#colors = Variants.objects.raw('SELECT * FROM product_variants WHERE product_id=%s GROUP BY color_id',[id])
colors = Variants.objects.filter(
product_id=id).distinct('color_id')
print(colors)
colors.group_by = ['color_id']
results = QuerySet(query=colors, model=Variants)
#print(results)
#raw('SELECT * FROM product_variants WHERE product_id=%s GROUP BY color_id',[id])
#colors = Variants.objects.raw('SELECT * FROM product_variants WHERE product_id=%s GROUP BY color_id',[id])
#colors = Variants.objects.filter(product_id=id,size_id=variants[0].size_id )
#sizes = Variants.objects.raw('SELECT * FROM product_variants WHERE product_id=%s GROUP BY size_id',[id])
sizes = Variants.objects.filter(product_id=id,
color_id=variants[0].color_id)
variant = Variants.objects.get(id=variants[0].id)
context.update({
'sizes': sizes,
'colors': colors,
'variant': variant,
'query': query,
"selected_c": c
})
else:
context.update({'product': product, 'images': images, 'selected_c': c})
return render(request, 'agents/detailed-product.html', context)
'''
def _get_shared_queryset(self):
qs = super(TranslationQueryset, self)._clone()
qs.__class__ = QuerySet
accessor = self.shared_model._meta.translations_accessor
# update using the real manager
return QuerySet(self.shared_model,
using=self.db).filter(**{'%s__in' % accessor: qs})
def _folder(self, related, filters, option=OPTION_MESSAGES, order_by=None):
"""Base code, in common to the folders."""
qs = self.all() if option == OPTION_MESSAGES else QuerySet(self.model, PostmanQuery(self.model), using=self._db)
if related:
qs = qs.select_related(*related)
if order_by:
qs = qs.order_by(order_by)
if isinstance(filters, (list, tuple)):
lookups = models.Q()
for filter in filters:
lookups |= models.Q(**filter)
else:
lookups = models.Q(**filters)
if option == OPTION_MESSAGES:
return qs.filter(lookups)
# Adding a 'count' attribute, to be similar to the by-conversation case,
# should not be necessary. Otherwise add:
# .extra(select={'count': 'SELECT 1'})
else:
qs = qs.extra(select={'count': '{0}.count'.format(qs.query.pm_alias_prefix)})
qs.query.pm_set_extra(table=(
# extra columns are always first in the SELECT query
self.filter(lookups, thread_id__isnull=True).extra(select={'count': 0})\
.values_list('id', 'count').order_by(),
# use separate annotate() to keep control of the necessary order
self.filter(lookups, thread_id__isnull=False).values('thread').annotate(count=models.Count('pk')).annotate(id=models.Max('pk'))\
.values_list('id', 'count').order_by(),
))
return qs
def mock_enrollment_data(self, has_enrollments):
result = EventEnrollmentManager()
data = []
max_event_id = 0
for index in range(TestApi.NUM_DAILY_EVENTS +
TestApi.NUM_WEEKLY_EVENTS):
item = {}
item['enrollment_id'] = index + 10
item['event_id'] = index
item['roster_id'] = 1
data.append(item)
max_event_id = TestApi.NUM_DAILY_EVENTS + TestApi.NUM_WEEKLY_EVENTS
for index in range(TestApi.NUM_DAILY_EVENTS):
item = {}
item['enrollment_id'] = max_event_id + index + 10
item['event_id'] = max_event_id + index
item['roster_id'] = 1
data.append(item)
queryset = QuerySet()
result.filter = MagicMock(return_value=queryset)
if has_enrollments:
queryset.values = MagicMock(return_value=data)
else:
queryset.values = MagicMock(return_value=[])
return result
def filter_fields_to_type(klass, query_dict):
reserved_fields = ['order_by', 'format', 'limit', 'offset']
q = QuerySet(klass)
query = dict(query_dict)
fields = {}
for field in q.model._meta.fields:
fields[field.column] = field
# Remove the reserved fields we know about.
for field in query.keys():
if field in reserved_fields:
del query[field]
# This will error if it find an unknown field and cause the standard tasty pie query to run.
for field in query.keys():
try:
field_type = type(fields[field])
value = query[field]
if field_type == django_fields.AutoField or field_type == django_fields.IntegerField:
value = int(value)
elif field_type == django_fields.BooleanField:
value = (value.lower() == 'true')
query[field] = value
except KeyError:
pass
return query
def mock_event_data(self):
result = EventManager()
data = []
max_event_id = 0
# Make a 'class' for each class designated
for index in range(TestApi.NUM_DAILY_EVENTS +
TestApi.NUM_WEEKLY_EVENTS):
item = {}
item['event_id'] = index
item['event_name'] = "Event " + str(index)
item['meeting_link'] = "https://www.google.fake"
item['section'] = "fake"
item['year'] = TestApi.SCHEDULED_YEAR
data.append(item)
max_event_id = index
max_event_id = max_event_id + 1
# Make a 'class' for each daily designated class for previous year
for index in range(TestApi.NUM_DAILY_EVENTS):
item = {}
item['event_id'] = index + max_event_id
item['event_name'] = "Event " + str(index + max_event_id)
item['meeting_link'] = "https://www.google.fake"
item['section'] = "fake"
item['year'] = TestApi.EARLY_YEAR
data.append(item)
queryset = QuerySet()
result.filter = MagicMock(return_value=queryset)
queryset.values = MagicMock(return_value=data)
return result
def test_basic(self):
from django.db.models.query import QuerySet
obj = QuerySet(model=TestModel)
result = transform(obj)
self.assertTrue(isinstance(result, six.string_types))
self.assertEquals(result, '<QuerySet: model=TestModel>')
def buildHistoryNodes(self, parentNode):
node0 = self.addLINode(parentNode,
id="alertHistory",
apiName="getAlertHistory",
apiData="server_id" + const.APIDATA_EQUAL)
self.addLinkNode(node0, "All", url="#", id="0")
endDate = datetime.datetime.today()
startDate = endDate - datetime.timedelta(days=7)
query = vo_AlertHistory.objects.all().query
query.group_by = ['server_id', 'regdate']
results = QuerySet(query=query, model=vo_AlertHistory)
menuNode = parentNode
#for item in vo_AlertHistory.objects.filter(regdate__range=[startDate,endDate]):
for item in results:
plugin = item.plugin
apidata = "server_id" + const.APIDATA_EQUAL + str(item.server.id)
#apidata = apidate+const.APIDATA_SEPERATOR+"alerthistory_id"+const.APIDATA_EQUAL+str(item.id)
serverNode = self.findServerNode(parentNode, item.server.ip)
if not serverNode:
node1 = self.addLINode(parentNode,
id=item.server.ip,
apiName="getAlertHistory",
apiData=apidata)
self.addLinkNode(node1,
item.server.ip,
url="#",
id=str(item.id))
def test_basic(self, mytest_model):
from django.db.models.query import QuerySet
obj = QuerySet(model=mytest_model)
result = transform(obj)
assert isinstance(result, string_types)
assert result == '<QuerySet: model=MyTestModel>'
def foreignkey_autocomplete(self, request):
"""
Search in the fields of the given related model and returns the
result as a simple string to be used by the jQuery Autocomplete plugin
"""
query = request.GET.get('q', None)
app_label = request.GET.get('app_label', None)
model_name = request.GET.get('model_name', None)
search_fields = request.GET.get('search_fields', None)
object_pk = request.GET.get('object_pk', None)
try:
to_string_function = self.related_string_functions[model_name]
except KeyError:
if six.PY3:
to_string_function = lambda x: x.__str__()
else:
to_string_function = lambda x: x.__unicode__()
if search_fields and app_label and model_name and (query or object_pk):
def construct_search(field_name):
# use different lookup methods depending on the notation
if field_name.startswith('^'):
return "%s__istartswith" % field_name[1:]
elif field_name.startswith('='):
return "%s__iexact" % field_name[1:]
elif field_name.startswith('@'):
return "%s__search" % field_name[1:]
else:
return "%s__icontains" % field_name
model = apps.get_model(app_label, model_name)
queryset = model._default_manager.all()
data = ''
if query:
for bit in query.split():
or_queries = [models.Q(**{construct_search(smart_str(field_name)): smart_str(bit)}) for field_name in search_fields.split(',')]
other_qs = QuerySet(model)
other_qs.query.select_related = queryset.query.select_related
other_qs = other_qs.filter(reduce(operator.or_, or_queries))
queryset = queryset & other_qs
additional_filter = self.get_related_filter(model, request)
if additional_filter:
queryset = queryset.filter(additional_filter)
if self.autocomplete_limit:
queryset = queryset[:self.autocomplete_limit]
data = ''.join([six.u('%s|%s\n') % (to_string_function(f), f.pk) for f in queryset])
elif object_pk:
try:
obj = queryset.get(pk=object_pk)
except Exception: # FIXME: use stricter exception checking
pass
else:
data = to_string_function(obj)
return HttpResponse(data, content_type='text/plain')
return HttpResponseNotFound()
