def mptt_build_tree(queryset, children_key):
'''
:param queryset: the entire tree, or portion of tree, you're trying to construct
:param children_key: key to store children, can't be a field name that's already on the model
:return: QuerySet, with children (also QuerySets) properly nested to each level present
'''
nodes = OrderedDict()
nodes_children = OrderedDict()
for row in queryset:
nodes[row.id] = row
if nodes_children.get(row.parent_id):
nodes_children[row.parent_id]._result_cache.append(row)
else:
nodes_children[row.parent_id] = QuerySet()
nodes_children[row.parent_id]._result_cache = [row]
for k, node in nodes.iteritems():
# Try to find the parent so we can attach the child nodes
setattr(node, children_key, QuerySet())
children = getattr(node, children_key)
children._result_cache = []
if nodes.get(node.parent_id):
children = getattr(nodes[node.parent_id], children_key)
children._result_cache.append(node)
# Build out root nodes for the base level of the list
root_nodes = QuerySet()
root_nodes._result_cache = []
for node_id, node in nodes.iteritems():
if node.parent_id is None:
root_nodes._result_cache.append(node)
return root_nodes
def home_article():
iif_list = [1, 2, 3, 4, 5, 6] # Industry information
pct_list = [7, 8, 9, 10] # Press control
iif_query = Article.objects.filter(type__in=iif_list).query
pct_query = Article.objects.filter(type__in=pct_list).query
iif_query.group_by = ['type']
pct_query.group_by = ['type']
iif = QuerySet(query=iif_query, model=Article)
pct = QuerySet(query=pct_query, model=Article)
return iif, pct
def create_allowed_operation(allowed_groups: QuerySet(MrMapGroup),
operations: QuerySet(OGCOperation),
root_metadata: Metadata,
how_much_allowed_operations: int = 1,
allowed_area: MultiPolygon = None,):
return baker.make_recipe(
"tests.baker_recipes.service_app.allowed_operation",
_quantity=how_much_allowed_operations,
root_metadata=root_metadata,
allowed_groups=allowed_groups,
operations=operations,
allowed_area=allowed_area,
)
class CountryViewSet(viewsets.GenericViewSet):
queryset = QuerySet()
serializer_class = CountrySerializer
pagination_class = PageNumberPagination
schema = NoModelAutoSchema(path_parameters=dict(id=PathParameter(
scheme_type='UUID type', description='id of a country')), )
def retrieve(self, request, *args, **kwargs):
instance = countries[0]
serializer = self.get_serializer(instance)
return Response(serializer.data)
@custom_parameters(query_serializer=CountryQuerySerializer,
response_serializer=CountryResponseSerializer)
def list(self, request, *args, **kwargs):
page = self.paginate_queryset(countries)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(countries, many=True)
return Response(serializer.data)
@action(methods=['GET'], detail=True)
def help(self, request, *args, **kwargs):
instance = countries[0]
serializer = self.get_serializer(instance)
return Response(serializer.data)
def get_library_card(request):
# if this is a POST request we need to process the form data
if request.method == 'GET':
# create a form instance and populate it with data from the request:
form = GetLibraryCardForm(request.GET)
# check whether it's valid:
if form.is_valid():
# process the data in form.cleaned_data as required
# ...
# redirect to a new URL:
input_type = form.cleaned_data['input_type']
b = QuerySet()
if input_type.lower() == 'id':
b = library_cards.get_by_id(form.cleaned_data['input'])
elif input_type.lower() == 'name':
b = library_cards.get_by_name(form.cleaned_data['input'])
else:
return HttpResponse('Invalid type')
if len(b) == 0:
return HttpResponse('No library cards were found')
return HttpResponse(b)
# if a GET (or any other method) we'll create a blank form
else:
form = GetLibraryCardForm()
return render(request, 'website_frontend/get_library_card.html/',
{'form': form})
def __init__(self, field, value):
self.field = field
self.attname = getattr(self.field, 'attname', None)
self.field_bound = self.attname is not None
self.qs = (self.field.model._default_manager.all()
if self.field_bound else QuerySet())
self.value = value
def patch(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse:
# permission check deferred to .perform_update()
instance = self.model_object
has_read_permissions = False
if p.has_perms_shortcut(self.user_object, instance, "r"):
has_read_permissions = True
serializer = self.get_serializer(
instance=instance,
data=self.request_data,
partial=True,
)
serializer.is_valid(raise_exception=True)
# User must have write permission on the field being modified.
for field_name, field_val in serializer.validated_data.items():
# Note that in case field_name is a foreign key, there are two
# cases:
# 1. brand
# 2. brand_id
# If the field_name is brand then field_val is usually a brand
# object. If the field name is brand_id, then field val is UUID.
field = self.get_model_field(field_name)
if not field:
continue
# For foreign keys, user must have 3-way permissions. See
# .check_3way_permissions().
if isinstance(field, ForeignKey):
field_name = field.name # this removes "_id"
if isinstance(field_val, DCFModel):
field_val_pk = field_val.pk
else:
field_val_pk = field_val
new_related_obj: QuerySet = QuerySet(model=field.related_model).filter(
pk=field_val_pk
)
if not new_related_obj.exists():
raise e.NotFound(f"Related object {field_val_pk} does not exist.")
self.check_3way_permissions(
self.user_object,
self.model_object,
field_name,
new_related_obj,
"w",
)
elif not p.has_perms_shortcut(
self.user_object, self.model_object, "w", field_name
):
raise APIPermissionDenied(self.model_object, "w", field=field_name)
# when permited
serializer.save()
if has_read_permissions:
p.add_perms_shortcut(self.user_object, instance, "r")
if p.has_perms_shortcut(self.user_object, instance, "r"):
return Response(
self.get_serializer(instance=instance).data,
status=200,
)
else:
raise UpdatedHiddenObject()
class ResultsListView(ListView):
template_name = 'library/results_list.html'
qs = QuerySet()
def get_queryset(self):
return self.qs
def get(self, request, *args, **kwargs):
query = request.GET.get("q")
if query:
self.qs = ProductFamily.objects.filter(
productmodel__model_number__icontains=query).distinct()
if not self.qs:
self.qs = ProductModel.objects.filter(
family_id__family_name__icontains=query)
else:
self.qs = {}
return super().get(request, *args, **kwargs)
def get_context_data(self, *, object_list=None, **kwargs):
context = super().get_context_data(**kwargs)
context['search_results'] = self.qs
context['user'] = Profile.objects.filter(
user=self.request.user).first()
return context
class TestCommandMethods(TestCase):
@patch(
'jarbas.chamber_of_deputies.management.commands.receipts.Command.update'
)
@patch(
'jarbas.chamber_of_deputies.management.commands.receipts.Command.bulk_update'
)
@patch(
'jarbas.chamber_of_deputies.management.commands.receipts.Command.print_count'
)
def test_fetch(self, print_count, bulk_update, update):
command = Command()
command.count = 0
command.queryset = (1, 2, 3)
command.queue = []
command.fetch()
print_count.assert_has_calls((call(), call(), call()))
update.assert_has_calls(call(i) for i in range(1, 4))
self.assertEqual(3, command.count)
bulk_update.assert_called_once_with()
@patch.object(QuerySet, '__getitem__')
@patch.object(QuerySet, 'filter', return_value=QuerySet())
def test_get_queryset(self, filter_, getitem):
command = Command()
command.batch = 42
command.get_queryset()
filter_.assert_called_once_with(receipt_fetched=False)
getitem.assert_called_once_with(slice(None, 42))
def test_update(self):
reimbursement = Mock()
command = Command()
command.queue = []
command.update(reimbursement)
reimbursement.get_receipt_url.assert_called_once_with(bulk=True)
self.assertEqual(1, len(command.queue))
def test_update_with_error(self):
reimbursement = Mock()
reimbursement.get_receipt_url.side_effect = ConnectionError()
command = Command()
command.queue = []
command.update(reimbursement)
reimbursement.get_receipt_url.assert_called_once_with(bulk=True)
self.assertEqual(0, len(command.queue))
@patch(
'jarbas.chamber_of_deputies.management.commands.receipts.bulk_update')
@patch(
'jarbas.chamber_of_deputies.management.commands.receipts.Command.print_saving'
)
def test_bulk_update(self, print_saving, bulk_update):
command = Command()
command.queue = [1, 2, 3]
command.bulk_update()
fields = ['receipt_url', 'receipt_fetched']
bulk_update.assert_called_once_with([1, 2, 3], update_fields=fields)
self.assertEqual([], command.queue)
print_saving.assert_called_once_with()
def album_detail(request):
"""显示专辑中的歌曲信息"""
albumId = request.GET.get('albumId')
leixin = "专辑"
lists = QuerySet()
name = ""
if albumId is None:
lists = SongItem.objects.get_queryset().order_by('id')
else:
lists = SongItem.objects.filter(albumid=albumId)
print(lists)
if lists:
t = get_template("albumDetail.html")
paginator = Paginator(lists, 10)
page = request.GET.get('page', 1)
# 把当前的页码数转换成整数类型
currentPage = int(page)
it = range(1, 10)
try:
lists = paginator.page(page) # 获取当前页码的记录
except PageNotAnInteger:
lists = paginator.page(1) # 如果用户输入的页码不是整数时,显示第1页的内容
except EmptyPage:
# 如果用户输入的页数不在系统的页码列表中时,显示最后一页的内容
lists = paginator.page(paginator.num_pages)
html = t.render(locals())
return HttpResponse(html)
else:
t = get_template("spider.html")
id = albumId
name = AlbumItem.objects.get(albumid=albumId).albumname
kind = "专辑"
kindId = 1
html = t.render(locals())
return HttpResponse(html)
class ProductTypeListView(FormMixin, ListView):
model = ProductType
context_object_name = 'types'
form_class = MainSearch
qs = QuerySet()
def get(self, request, *args, **kwargs):
if request.GET:
view = ResolutionsResultsView.as_view()
return view(request, *args, **kwargs)
# query = request.GET.get("q")
# if query:
# self.qs = ProductFamily.objects.filter(productmodel__model_number__icontains=query).distinct()
# if not self.qs:
# self.qs = ProductModel.objects.filter(family_id__family_name__icontains=query)
# else:
# self.qs = {}
return super().get(request, *args, **kwargs)
def get_context_data(self, *, object_list=None, **kwargs):
context = super().get_context_data(**kwargs)
context['search_results'] = self.qs
context['model_count'] = ProductModel.objects.all().count()
context['user_count'] = User.objects.all().count()
return context
class DashboardStatisticView(BasicInfoViewSet):
"""仪表板统计数据接口"""
queryset = QuerySet()
serializer_class = DoNothingSerializer
permission_name = permissions.PER_DASHBOARD
http_method_names = ('get', )
def get(self, request, *args, **kwargs):
"""获取资源数据
Args:
request(Request): http request
*args(list): 可变参数
**kwargs(dict): 可变关键字参数
Returns:
response(Response): 响应数据
"""
articles = models.Article.objects.all()
data = {
"article_count": articles.count(),
"unpublish_count": articles.filter(is_publish=False).count(),
"tags_count": models.ArticleTag.objects.count(),
"comment_count": adapt_get_comment_count(),
"access_count": models.AccessRecord.objects.count(),
"flink_apply": models.FriendlyLink.objects.filter(enable=False).count(),
"fans_count": models.SubscribeRecord.objects.all().count()
}
return self.set_response(result='Success', data=[data, ])
def get_most_sold_products(self):
products = QuerySet(Product)
for subcategory in self.subcategories.all():
products = (products | subcategory.get_most_sold_products())
return products.order_by('-sold')[:5]
class IndexShowCardInfoView(BasicInfoViewSet):
"""个人名片数据接口"""
queryset = QuerySet()
serializer_class = DoNothingSerializer
permission_name = permissions.PER_SHOW_CARD
authentication_enable = False
http_method_names = ('get', )
def get(self, request, *args, **kwargs):
"""获取资源数据
Args:
request(Request): http request
*args(list): 可变参数
**kwargs(dict): 可变关键字参数
Returns:
response(Response): 响应数据
"""
data = {
"article_count": Article.objects.filter(is_publish=True).count(),
"fans_count": SubscribeRecord.objects.count(),
"classify_count": ArticleClassify.objects.count(),
"comment_count": adapt_get_comment_count(),
"access_count": AccessRecord.objects.count(),
}
return self.set_response(result='Success', data=[
data,
])
def get_searched_queryset(self, qs):
""" CUSTOM """
model = self.model
term = self.GET[
"filter[value]"] # ho cambiato da "term" a "filter[value]"
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.module_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
class KeywordsAPIView(ListAPIView):
"""
This endpoint returns suggestions about what a user may be typing.
Call this endpoint when a user is typing a search and display the results (for instance below the search bar).
This endpoint only completes queries that are at least 4 characters.
"""
serializer_class = KeywordsRequestSerializer
permission_classes = (AllowAny, )
schema = SearchSchema()
queryset = QuerySet()
pagination_class = None
filter_backends = []
def get(self, request, *args, **kwargs):
# validate request parameters
serializer = KeywordsRequestSerializer(data=request.GET)
serializer.is_valid(raise_exception=True)
data = serializer.validated_data
client = SearchApiClient()
res = client.autocomplete(**data)
return Response(res)
class DashboardArticleChart(BasicInfoViewSet):
"""仪表板文章发表数据柱状图接口"""
queryset = QuerySet()
serializer_class = DoNothingSerializer
permission_name = permissions.PER_DASHBOARD
http_method_names = ('get',)
def get(self, request, *args, **kwargs):
"""获取资源数据
Args:
request(Request): http request
*args(list): 可变参数
**kwargs(dict): 可变关键字参数
Returns:
response(Response): 响应数据
"""
data = list()
now = datetime.datetime.now()
flag = 31
while flag != 0:
data.insert(0, {
"date": now.strftime("%m-%d"),
"count": models.Article.objects.filter(
ctime__year=now.year, ctime__month=now.month, ctime__day=now.day
).count()
})
now -= datetime.timedelta(days=1)
flag -= 1
return self.set_response(result='Success', data=data)
def getInbox(request, id_receiver):
if request.method == 'GET':
query = Message.objects.all().query
query.group_by = ['id_sender']
queryset = QuerySet(query=query, model=Message).filter(
id_receiver=id_receiver).order_by('date_time')
serializer = MessageSerializer(queryset, many=True)
return Response(serializer.data)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
functions = self.get_functions()
context['form'].fields['function'] = ModelChoiceField(QuerySet())
context['form'].fields['function'].label = 'Обработчик'
context['form'].fields['function'].widget = Select(attrs={'class': 'form-control border'})
context['form'].fields['function'].choices = [[cls_name, cls_obj.label] for cls_name, cls_obj in functions]
return context
def people(self, request: request.Request, *args: Any,
**kwargs: Any) -> Response:
team = request.user.team_set.get()
filter = Filter(request=request)
def _calculate_people(events: QuerySet):
shown_as = request.GET.get('shown_as')
if shown_as is not None and shown_as == 'Stickiness':
stickiness_days = int(request.GET['stickiness_days'])
events = events\
.values('person_id')\
.annotate(day_count=Count(functions.TruncDay('timestamp'), distinct=True))\
.filter(day_count=stickiness_days)
else:
events = events.values('person_id').distinct()
if request.GET.get(
'breakdown_type'
) == 'cohort' and request.GET.get('breakdown_value') != 'all':
events = events.filter(
Exists(
CohortPeople.objects.filter(
cohort_id=int(request.GET['breakdown_value']),
person_id=OuterRef('person_id')).only('id')))
people = Person.objects\
.filter(team=team, id__in=[p['person_id'] for p in events[0:100]])
people = people.prefetch_related(
Prefetch('persondistinctid_set', to_attr='distinct_ids_cache'))
return self._serialize_people(people=people, request=request)
filtered_events: QuerySet = QuerySet()
if request.GET.get('session'):
filtered_events = Event.objects.filter(team=team).filter(
self._filter_events(filter)).add_person_id(team.pk)
else:
entity = Entity({
'id': request.GET['entityId'],
'type': request.GET['type']
})
if entity.type == TREND_FILTER_TYPE_EVENTS:
filtered_events = self._process_entity_for_events(entity, team=team, order_by=None)\
.filter(self._filter_events(filter, entity))
elif entity.type == TREND_FILTER_TYPE_ACTIONS:
actions = super().get_queryset()
actions = actions.filter(deleted=False)
try:
action = actions.get(pk=entity.id)
except Action.DoesNotExist:
return Response([])
filtered_events = self._process_entity_for_events(
entity, team=team,
order_by=None).filter(self._filter_events(filter, entity))
people = _calculate_people(events=filtered_events)
return Response([people])
class DashboardProcessData(BasicInfoViewSet):
"""仪表板事件进度统计接口"""
queryset = QuerySet()
serializer_class = DoNothingSerializer
permission_name = permissions.PER_DASHBOARD
http_method_names = ('get',)
@staticmethod
def _get_article_update_rate(days=30):
"""获取文章的更新频率
Args:
days(int): 统计周期，默认为最近30天
Returns:
rate(float): 更新频率
"""
now = datetime.datetime.now()
start = now - datetime.timedelta(days=days)
date_range = (
f'{start.strftime("%F")} 00:00:00',
f'{now.strftime("%F")} 23:59:59'
)
obj = models.Article.objects.filter(ctime__range=date_range)
update_date = [qs.strftime("%F") for qs in obj.values_list('ctime', flat=True)]
update_date = list(set(update_date))
return round(len(update_date)*100 / days, 2)
@staticmethod
def _get_incomplete_task_rate():
"""获取未完成任务占比
Returns:
rate(float): 未完成任务占比
"""
total = models.ProjectPlanTask.objects.count()
incomplete = models.ProjectPlanTask.objects.filter(status=TASK_STATUS_PLAN).count()
if total == 0: # 如果没有计划任务，则未完成任务占比为0
return 0
return round(incomplete*100/total, 2)
def get(self, request, *args, **kwargs):
"""获取资源数据
Args:
request(Request): http request
*args(list): 可变参数
**kwargs(dict): 可变关键字参数
Returns:
response(Response): 响应数据
"""
data = list()
data.append({
"article_update_rate": self._get_article_update_rate(),
"task_incomplete_rate": self._get_incomplete_task_rate(),
})
return self.set_response(result='Success', data=data)
def notes(user: User, trash: bool = False) -> QuerySet:
"""
Returns all note belonging to the argument user if they are authenticated, otherwise it returns an empty QuerySet.
"""
if user.is_authenticated:
return Note.objects.filter(notebook__owner=user,
trash=trash).order_by('id')
else:
return QuerySet()
def _build_exhibition(self, exhibition_id):
home_exhibition = QuerySet(home_models.Exhibition)\
.filter(page_ptr_id=exhibition_id, live=True).first()
home_rooms = QuerySet(home_models.Room).filter(
exhibition_page=exhibition_id
)
rooms = self._build_rooms(home_rooms)
exhibition = Exhibition(
home_exhibition.page_title,
home_exhibition.strapline,
home_exhibition.flyer_image_id,
rooms
)
return exhibition
def notebooks(user: User) -> QuerySet:
"""
Returns all notebooks belonging to the argument user if they are authenticated, otherwise it returns an empty
QuerySet.
"""
if user.is_authenticated:
return Notebook.objects.filter(owner=user).order_by('id')
else:
return QuerySet()
def process_entity_for_events(entity: Entity, team_id: int, order_by="-id") -> QuerySet:
if entity.type == TREND_FILTER_TYPE_ACTIONS:
events = Event.objects.filter(action__pk=entity.id).add_person_id(team_id)
if order_by:
events = events.order_by(order_by)
return events
elif entity.type == TREND_FILTER_TYPE_EVENTS:
return Event.objects.filter_by_event_with_people(event=entity.id, team_id=team_id, order_by=order_by)
return QuerySet()
def viewDemo(request):
form = BookModleForm()
if request.method == "POST":
form = BookModleForm(request.POST)
if form.is_valid():
book_obj = Book.objects.create(**form.cleaned_data)
book_obj = QuerySet(book_obj)
print("is right=", serializers.serialize('json', book_obj))
return JsonResponse(serializers.serialize('json', book_obj))
return render(request, 'viewDemo.html', locals())
def addProperty(self, property, group):
hasCategory = group.Properties.filter(
Category=property.Category).exists()
group.Properties.append(property)
group.save()
if not hasCategory:
functions = self._createGroupDeviceFunctions(QuerySet(property))
group.Device.Functions += functions
group.Device.save() # TODO: use __groupDeviceService here
return group
def getLastCompetitions(length=6):
result_query = QuerySet(Competition)
for region in Competition.REGIONS:
result_query = result_query | Competition.objects\
.filter(is_creating_finished=True)\
.filter(started_at__gt=django.utils.timezone.now()) \
.filter(region=region[0]) \
.order_by('-started_at') \
.all()[:length]
return result_query.order_by('-started_at')
def vendor_customer_order(request):
vender_id_id = request.session['vendor_id']
v_id = request.session['vendor_id']
res = CartItemModel.objects.filter(status='Order',
food__food_type__vender_id=v_id)
q = CartItemModel.objects.filter(status='Order',
food__food_type__vender_id=v_id).query
q.group_by = ['customer_id']
res = QuerySet(query=q, model=CartItemModel)
print(res)
return render(request, 'vendor/customer_order.html', {"data": res})
def _build_walls(self, home_room):
home_walls = QuerySet(home_models.Wall).filter(room_page=home_room.id)
walls = []
for home_wall in home_walls:
images = self._build_images(home_wall)
media = self._build_media(home_wall)
wall = Wall(media, images)
walls.append(wall)
return walls
