def to_representation(self, value):
if not value:
# don't add anything when it's not set.
return value
parts = urlsplit(value)
query = QueryDict(parts.query, mutable=True)
query.update(amo.CONTRIBUTE_UTM_PARAMS)
return super().to_representation(
urlunsplit((
parts.scheme,
parts.netloc,
parts.path,
query.urlencode(),
parts.fragment,
)))
def update(self, request, pk=None):
try:
snippet = Meal.objects.get(pk=pk)
except Meal.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'PUT':
calorie = 0
if snippet.food_name == request.data['food_name'] and float(
request.data['calorie']) != float(0):
calorie = request.data['calorie']
serializer = MealSerializer(snippet, data=request.data)
else:
data = dict(request.data)
# \ or float(snippet.calorie) == float(data['calorie'][0])
if not data['calorie'] or float(
data['calorie'][0]) == float(0):
flag, val = nutritionnix_calorie_api(data['food_name'][0])
if flag:
data['calorie'][0] = val
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
calorie = data['calorie'][0]
query_dict = QueryDict('', mutable=True)
query_dict.update(MultiValueDict(data))
serializer = MealSerializer(snippet, data=query_dict)
if serializer.is_valid():
try:
if request.user.is_superuser:
user = UserProfile.objects.get(
pk=snippet.user_profile.id)
else:
user = UserProfile.objects.get(pk=self.request.user.id)
user.curr_calorie -= float(snippet.calorie)
user.curr_calorie += float(calorie)
if user.curr_calorie < user.max_calorie:
user.is_limit = False
else:
user.is_limit = True
user.save()
except:
return Response(status=status.HTTP_404_NOT_FOUND)
serializer.save()
return Response(serializer.data)
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def dispatch(self, request: HttpRequest, flow_slug: str) -> HttpResponse:
# Early check if theres an active Plan for the current session
if SESSION_KEY_PLAN in self.request.session:
self.plan = self.request.session[SESSION_KEY_PLAN]
if self.plan.flow_pk != self.flow.pk.hex:
self._logger.warning(
"f(exec): Found existing plan for other flow, deleteing plan",
)
# Existing plan is deleted from session and instance
self.plan = None
self.cancel()
self._logger.debug("f(exec): Continuing existing plan")
# Don't check session again as we've either already loaded the plan or we need to plan
if not self.plan:
self._logger.debug("f(exec): No active Plan found, initiating planner")
try:
self.plan = self._initiate_plan()
except FlowNonApplicableException as exc:
self._logger.warning(
"f(exec): Flow not applicable to current user", exc=exc
)
return to_stage_response(self.request, self.handle_invalid_flow(exc))
except EmptyFlowException as exc:
self._logger.warning("f(exec): Flow is empty", exc=exc)
# To match behaviour with loading an empty flow plan from cache,
# we don't show an error message here, but rather call _flow_done()
return self._flow_done()
# Initial flow request, check if we have an upstream query string passed in
request.session[SESSION_KEY_GET] = QueryDict(request.GET.get("query", ""))
# We don't save the Plan after getting the next stage
# as it hasn't been successfully passed yet
next_stage = self.plan.next(self.request)
if not next_stage:
self._logger.debug("f(exec): no more stages, flow is done.")
return self._flow_done()
self.current_stage = next_stage
self._logger.debug(
"f(exec): Current stage",
current_stage=self.current_stage,
flow_slug=self.flow.slug,
)
stage_cls = self.current_stage.type
self.current_stage_view = stage_cls(self)
self.current_stage_view.args = self.args
self.current_stage_view.kwargs = self.kwargs
self.current_stage_view.request = request
return super().dispatch(request)
def __init__(self,
page_num,
all_count,
params=None,
per_num=10,
max_show=11):
"""
:param page_num: 当前的页码数
:param all_count: 总数据量
:param per_num: 每页显示的数据条数
:param max_show: 最大显示页码数
:param self.total_page_num: 总页码数
:param self.page_start: 起始页码数
:param self.page_end: 终止页码数
"""
try:
page_num = int(page_num)
if page_num <= 0:
page_num = 1
except Exception as e:
page_num = 1
self.parmas = params if params else QueryDict(mutable=True)
self.page_num = page_num
self.all_count = all_count
self.per_num = per_num
total_page_num, more = divmod(all_count, per_num)
if more:
total_page_num += 1
half_show = max_show // 2
# 总页码数不足以满足最大页码数
if total_page_num < max_show:
page_start = 1
page_end = total_page_num
else:
if page_num - half_show <= 0:
page_start = 1
page_end = max_show
elif page_num + half_show > total_page_num:
page_start = total_page_num - max_show + 1
page_end = total_page_num
else:
page_start = page_num - half_show
page_end = page_num + half_show
self.page_start = page_start
self.page_end = page_end
self.total_page_num = total_page_num
def _add_nested_data(self, request: Request, data_item: dict,
relationships: List[Tuple[Relationship, bool]],
origin_lookup_field: str) -> None:
""" Nests data retrieved from related services """
origin_pk = data_item.get(origin_lookup_field)
if not origin_pk:
raise exceptions.DataMeshError(
f'DataMeshConfigurationError: lookup_field_name "{origin_lookup_field}" '
f'not found in response.')
for relationship, is_forward_lookup in relationships:
join_records = JoinRecord.objects.get_join_records(
origin_pk, relationship, is_forward_lookup)
# now backwards get related objects through join_records
if join_records:
related_objects = []
related_model, related_record_field = datamesh_utils.prepare_lookup_kwargs(
is_forward_lookup, relationship, join_records[0])
app = self._load_swagger_resource(
related_model.logic_module_endpoint_name)
for join_record in join_records:
# remove query_params from original request
request._request.GET = QueryDict(mutable=True)
request_kwargs = {
'pk': (str(getattr(join_record,
related_record_field))),
'model': related_model.endpoint.strip('/'),
'method': request.META['REQUEST_METHOD'].lower()
}
# create and perform a service request
response = self._perform_service_request(app=app,
request=request,
**request_kwargs)
if response.data:
related_objects.append(dict(response.data))
else:
logger.error(
f'No response data for join record (request params: {request_kwargs})'
)
# aggregate
data_item[relationship.key] = related_objects
def connect(self):
self.accept()
query_string = self.scope.get('query_string')
# print(query_string)
ssh_args = QueryDict(query_string=query_string, encoding='utf-8')
width = int(ssh_args.get('width'))
height = int(ssh_args.get('height'))
port = int(ssh_args.get('port'))
auth = ssh_args.get('auth')
ssh_key_name = ssh_args.get('ssh_key')
passwd = ssh_args.get('password')
host = ssh_args.get('host')
user = ssh_args.get('user')
if passwd:
passwd = base64.b64decode(passwd).decode('utf-8')
# password = password
else:
passwd = None
self.ssh = SSH(websocket=self, message=self.message)
ssh_connect_dict = {
'host': host,
'user': user,
'port': port,
'timeout': 30,
'pty_width': width,
'pty_height': height,
'password': passwd
}
if auth == 'key':
ssh_key_file = os.path.join(TMP_DIR, ssh_key_name)
with open(ssh_key_file, 'r') as fp:
ssh_key = fp.read()
string_io = StringIO()
string_io.write(ssh_key)
string_io.flush()
string_io.seek()
ssh_connect_dict['ssh_key'] = string_io
os.remove(ssh_key_file)
# print(ssh_connect_dict)
self.ssh.connect(**ssh_connect_dict)
def product_selector_ui_extra_context(view):
extra_context = dict()
# Captured values
kwargs = view.kwargs
step = int(kwargs.get('step'))
# Post data
data = kwargs.get('POST') or QueryDict()
config_id = data.get('config_id')
type_id = data.get('type_id')
extra_context['step'] = step
if step == 1:
extra_context['configs'] = Config.objects.order_by('id').all()
elif step == 2:
extra_context['types'] = Config.objects.get(id=config_id).types()
elif step == 3:
config = Config.objects.get(id=config_id)
products = config.products().filter(track_item=True, type__id=type_id)
# Handling special cases, if there is parent product e.g. FB1, replaces with sub products
if config_id == '5':
fb_related_products = AbstractProduct.objects.filter(
track_item=False, code__icontains='FB')
products = products.exclude(
name__icontains='FB') | fb_related_products
# Handling special cases, replace origin seafoods parent with sub product
if config_id == '13' and type_id == '2':
products = config.products().filter(track_item=False,
type__id=type_id)
# Show products parent name and products name or code in select list
if config_id in ['8', '10', '11', '12'
] or config_id == '13' and type_id == '2':
extra_context['show_parent'] = True
# Show products parent name and code in select list
if config_id in ['5', '6', '7', '13'] and type_id == '1':
extra_context['show_code'] = True
extra_context['config_id'] = int(config_id)
extra_context['products'] = products
extra_context['sources'] = config.source_set.all().filter(
type__id=type_id)
return extra_context
def delete_domain(request):
response = BaseResponse()
try:
response.error = {}
post_dict = QueryDict(request.body, encoding='utf-8')
domain_id = post_dict.get('domain_id')
data_from_db = repository_models.WebConfigDomains.objects.get(
id=domain_id)
data_from_db.delete()
except Exception as e:
print(Exception, e)
response.status = False
response.message = str(e)
return response
def delete(self, model_obj=None, is_header=False):
if is_header:
return '删除'
else:
from django.http.request import QueryDict
parms_dict = QueryDict(mutable=True)
if self.request.method == 'GET':
parms_dict['_changelistfilter'] = self.request.GET.urlencode()
name = '{0}:{1}_{2}_delete'.format(self.site.namespace,
model_obj._meta.app_label,
model_obj._meta.model_name)
url = reverse(name,
args=(model_obj.pk, )) # s生成的结果同上方的edit pk和id同样
delete_url = '{0}?{1}'.format(url, parms_dict.urlencode())
delete_tag = '<a href="%s">删除</a>' % delete_url
return mark_safe(delete_tag)
def data_update(request):
response = BaseResponse()
try:
put_data = QueryDict(request.body, encoding='utf-8')
obj_id = put_data.get('id')
update_data = OMTOOLS_MODELS.MongodbMission.objects.get(id=obj_id)
update_data.op_user_id = request.user.id
update_data.status = 1
update_data.save()
except Exception as e:
print(Exception, e)
response.status = False
response.message = str(e)
return response
def on_user_logged_out(sender, request, user, **kwargs):
if not settings.AUTH_OPENID:
return
query = QueryDict('', mutable=True)
query.update({
'redirect_uri': settings.BASE_SITE_URL
})
openid_logout_url = "%s?%s" % (
client.openid_connect_client.get_url(
name='end_session_endpoint'),
query.urlencode()
)
request.COOKIES['next'] = openid_logout_url
def delete_server_instance(request):
response = BaseResponse()
try:
response.error = {}
post_dict = QueryDict(request.body, encoding='utf-8')
delete_instance_id = post_dict.get('instance_id')
get_data_from_db = repository_models.AppInstances.objects.get(
id=delete_instance_id)
get_data_from_db.delete()
except Exception as e:
print(Exception, e)
response.status = False
response.message = str(e)
return response
def delete_assets(request):
response = BaseResponse()
print('delete')
try:
delete_dict = QueryDict(request.body,encoding='utf-8') ##get id_list
id_list = delete_dict.getlist('id_list')
print(id_list)
models.Asset.objects.filter(ni__in=id_list).delete()
response.message = '删除成功'
except Exception as e:
response.status = False
print(e)
response.message = str(e)
return response
def get(self, request, *args, **kwargs):
page = self.get_page()
post_data, timestamp = self.request.session.get(self.session_key,
(None, None))
if not isinstance(post_data, str):
post_data = ''
form = self.get_form(page, QueryDict(post_data))
if not form.is_valid():
return self.error_response(page)
form.save(commit=False)
preview_mode = request.GET.get('mode', page.default_preview_mode)
return page.serve_preview(page.dummy_request(request),
preview_mode)
def test_view_helpers(self):
dictionary = {'max': ['3'], 'type': ['download'], 'jurisdiction_name': ['alabama']}
query_params = QueryDict('', mutable=True)
query_params.update(MultiValueDict(dictionary))
formatted_params = view_helpers.format_query(query_params, dict())
"""
assert type is removed
"""
assert 'type' not in formatted_params
assert 'max' not in formatted_params
queries = list(map(view_helpers.make_query, list(formatted_params.items())))
assert len(queries) == 1
first_q = queries[0]
assert first_q.children[0][0] == 'jurisdiction__name__icontains'
def get_form(self):
page = self.get_page()
form_class = page.get_edit_handler().get_form_class(page._meta.model)
parent_page = page.get_parent().specific
if self.session_key not in self.request.session:
# Session key not in session, returning null form
return form_class(instance=page, parent_page=parent_page)
post_data_dict, timestamp = self.request.session[self.session_key]
# convert post_data_dict back into a QueryDict
post_data = QueryDict('', mutable=True)
for k, v in post_data_dict.items():
post_data.setlist(k, v)
return form_class(post_data, instance=page, parent_page=parent_page)
def render(self, context):
request = context['request']
# Make request.GET mutable.
# request.GET = dict(request.GET)
if self.var_name in request.GET:
return ''
else:
mydict = {self.var_name: 1}
qdict = QueryDict('')
qdict = request.GET.copy()
qdict.update(mydict)
request.GET = qdict
# request.GET[self.var_name] = 1
return self.nodelist.render(context)
def add_btn(self):
"""
列表页面定制新建数据按钮
:return:
"""
add_url = reverse(
'%s:%s_%s_add' %
(self.arya_modal.site.namespace, self.arya_modal.app_label,
self.arya_modal.model_name))
_change = QueryDict(mutable=True)
_change['_change_filter'] = self.request.GET.urlencode()
tpl = "<a class='btn btn-success' style='float:right' href='{0}?{1}'><span class='glyphicon glyphicon-share-alt' aria-hidden='true'></span> 新建数据</a>".format(
add_url, _change.urlencode())
return mark_safe(tpl)
def delete_server_instance(request):
response = BaseResponse()
try:
response.error = {}
post_dict = QueryDict(request.body, encoding='utf-8')
group_id = post_dict.get('group_id')
docker_id = post_dict.get('docker_id')
add_to_db = repository_models.AppGroups.objects.get(id=group_id)
add_to_db.docker.remove(CMDB_MODELS.DockerInstance.objects.get(id=docker_id))
except Exception as e:
response.status = False
response.message = str(e)
return response
def test_create_with_file(self):
data = {
'page.title': 'some page',
'source': get_sample_file(name='sample name')
}
qdict = QueryDict('', mutable=True)
qdict.update(data)
serializer = serializers.DocumentSerializer(
data=qdict
)
serializer.is_valid(raise_exception=True)
doc = serializer.save()
self.assertTrue(models.Document.objects.filter(pk=doc.pk).exists())
self.assertEqual(doc.page.title, 'some page')
def resolve_url(request,url_name,cid):
"""
:param request: 请求对象
:param url_name: url别名
:param cid: 客户id
:return:
"""
from django.http.request import QueryDict
custom_query_dict = QueryDict(mutable=True)
custom_query_dict['next'] = request.get_full_path() #要跳转回的url
next_url = custom_query_dict.urlencode() #将得到的搜索路径url编码
reverse_url = reverse(url_name,args=(cid,)) #编辑的url ?next=要跳转的url
full_path = reverse_url + '?' + next_url
return full_path
def delete_assets(request):
response = BaseResponse()
try:
delete_dict = QueryDict(request.body, encoding='utf-8')
id_list = delete_dict.getlist('id_list')
status = models.ReleaseTask.objects.filter(id=id_list[0]).first().release_status
if status != 4:
response.status = False
response.message = '非待审核状态不能删除'
else:
models.ReleaseTask.objects.filter(id__in=id_list).delete()
response.message = '删除成功'
except Exception as e:
response.status = True
# response.message = str(e)
return response
def asset_data_create(request):
response = BaseResponse()
try:
asset_data = QueryDict(request.body, encoding='utf-8')
new_asset_num = asset_num.asset_num_builder()
asset_sn = asset_data.get('sn')
Memory = int(asset_data.get('Memory'))
DeviceSize = int(asset_data.get('DeviceSize'))
cpu_count = int(asset_data.get('cpu_count'))
if not asset_sn:
asset_sn = new_asset_num
if not models.Server.objects.filter(
ipaddress=asset_data.get('ipaddress')):
# 创建asset obj
asset_obj = models.Asset(
device_type_id=asset_data.get('device_type_id'),
asset_num=new_asset_num,
sn=asset_sn,
idc_id=asset_data.get('idc_id'),
business_unit_id=asset_data.get('business_unit_id'),
manage_ip=asset_data.get('manage_ip'),
creator_id=request.user.id,
memo=asset_data.get('memo'))
asset_obj.save()
asset_obj.tag.add(asset_data.get('tag_id'))
# 创建server obj
server_obj = models.Server(
asset_id=asset_obj.id,
hostname=asset_data.get('hostname'),
ipaddress=asset_data.get('ipaddress'),
Memory=Memory,
DeviceSize=DeviceSize,
cpu_count=cpu_count,
configuration='( %sC /%sG /%sG )' %
(cpu_count, Memory, DeviceSize))
server_obj.save()
else:
response.status = False
response.message = 'Ipaddress is already in system, Please check.'
except Exception as e:
print(Exception, e)
response.status = False
response.message = str(e)
return response
def test_forms_courses_multi_values_in_querystring(self, *_):
"""
The fields from filter definitions should allow multiple values. The fields defined
on the form should ignore repeated values (limit, offset and query).
"""
form = CourseSearchForm(data=QueryDict(
query_string=("availability=coming_soon"
"&availability=ongoing"
"&languages=fr"
"&languages=en"
"&levels=1"
"&levels=2"
"&limit=9"
"&limit=11"
"&new=new"
"&offset=3"
"&offset=17"
"&organizations=10"
"&organizations=11"
"&query=maths"
"&query=physics"
"&scope=objects"
"&scope=filters"
"&subjects=1"
"&subjects=2")))
form.is_valid()
self.assertTrue(form.is_valid())
self.assertEqual(
form.cleaned_data,
{
"availability": ["coming_soon", "ongoing"],
"languages": ["fr", "en"],
"levels": ["1", "2"],
"levels_include": "",
"limit": 9,
"new": ["new"],
"offset": 3,
"organizations": ["10", "11"],
"organizations_include": "",
"persons": [],
"persons_include": "",
"query": "maths",
"scope": "objects",
"subjects": ["1", "2"],
"subjects_include": "",
},
)
def __init__(self, page, all_count, params, per_num=10, max_show=11):
try:
self.page = int(page)
if self.page <= 0:
self.page = 1
except Exception:
self.page = 1
# 查询条件
self.params = params
if not params:
self.params = QueryDict(mutable=True)
# 总的数据量
all_count = all_count
# 每页显示的数据量 10
# 总的页码数
total_num, more = divmod(all_count, per_num)
if more:
total_num += 1
# 最大显示的页码数
half_show = max_show // 2
if total_num <= max_show:
page_start = 1
page_end = total_num
else:
if self.page - half_show <= 0:
# 页码的起始值
page_start = 1
# 页码的终止值
page_end = max_show
elif self.page + half_show > total_num:
page_end = total_num
page_start = total_num - max_show + 1
else:
# 页码的起始值
page_start = self.page - half_show
# 页码的终止值
page_end = self.page + half_show
self.page_start = page_start
self.page_end = page_end
self.total_num = total_num
self.start = (self.page - 1) * per_num
self.end = self.page * per_num
def __init__(self,
request,
all_num,
params=None,
per_page=10,
max_item=11):
"""
:param request: request请求对象
:param all_num: 需要分页的数据量
:param per_page: 每页需要展示的数据条数
:param max_item: 显示的页码
page：如果page为非数字需要进行异常处理，并设置其为1
"""
try:
page = int(request.GET.get('page', 1))
page = 1 if page <= 0 else page
except Exception:
page = 1
# 查询条件
self.params = params
if not self.params:
self.params = QueryDict(mutable=True)
# total_page: 分的总页数
total_page, b = divmod(all_num, per_page)
total_page = total_page + 1 if b else total_page
# page 对超出边界的page进行限制
page = page if page < total_page else total_page
# end和start表示显示的起始页码, views函数需要
self.end = page * per_page
self.start = self.end - per_page
half_item = max_item // 2
# 表示页码的起始数
self.start_page = page - half_item
self.end_page = page + half_item
# page表示当前页码
self.page = page
self.max_item = max_item
self.total_page = total_page
self.start_page = 1 if self.start_page <= 0 else self.start_page
if self.end_page > self.total_page:
self.start_page = self.total_page - self.max_item + 1
self.end_page = self.start_page + self.max_item
if self.start < 0:
self.start = 1
self.end = 1
def edit_field(self, obj=None, is_header=False):
'''操作栏，生成'''
if is_header:
return '操作'
else:
# url 尾部的 字段
param_url = ""
if len(self.request.GET):
_change = QueryDict(mutable=True)
_change['_change_filter'] = self.request.GET.urlencode()
param_url = "?{0}".format(_change.urlencode())
to_user_id = obj.to_user_id
from_user_id = obj.from_user_id
user_info_nid = self.request.session.get('user_info').get('nid')
tpl_edit_url = "<a style='color:red'>编辑</a>"
if str(obj.status) != '1' and user_info_nid is to_user_id:
# 判断 任务状态是否完成，并且 任务处理人是否是登录用户
edit_url = reverse('{0}:{1}_{2}_change'.format(self.site.namespace, self.app_label, self.model_name),
args=(obj.pk,))
tpl_edit_url = "<a href='{0}{1}'>编辑</a>".format(edit_url, param_url)
tpl_del_url = "<a style='color:red'>删除</a>"
if user_info_nid is from_user_id:
# 判断 任务分发者 是当前登录用户，才有删除的功能
del_url = reverse('{0}:{1}_{2}_delete'.format(self.site.namespace, self.app_label, self.model_name),
args=(obj.pk,))
tpl_del_url = "<a href='{0}{1}'>删除</a>".format(del_url, param_url)
# 每个人都有查看详细页面的功能
detail_url = reverse('{0}:{1}_{2}_detail'.format(self.site.namespace, self.app_label, self.model_name),
args=(obj.pk,))
tpl_detail_url = "<a href='{0}{1}'>查看详细</a>".format(detail_url, param_url)
tpl_submit_url = '<a style="color:red">进入提交</a>'
if user_info_nid is to_user_id:
# 判断 当前登录用户是 任务处理者时，才能有编辑能力。
submit_url = reverse('{0}:{1}_{2}_submit'.format(self.site.namespace, self.app_label, self.model_name),
args=(obj.pk,))
tpl_submit_url = "<a href='{0}{1}'>进入提交</a>".format(submit_url, param_url)
tpl = "{0} | {1} | {2} | {3}".format(tpl_edit_url,
tpl_del_url,
tpl_detail_url,
tpl_submit_url)
return mark_safe(tpl)
def test_forms_courses_single_values_in_querystring(self, *_):
"""
The fields from filter definitions should be normalized as lists. The fields defined
on the form should be single values (limit, offset and query)
"""
form = CourseSearchForm(data=QueryDict(
query_string=("availability=coming_soon"
"&facet_sorting=count"
"&languages=fr"
"&levels=1"
"&limit=9"
"&new=new"
"&offset=3"
"&organizations=10"
"&query=maths"
"&scope=objects"
"&subjects=1")))
self.assertTrue(form.is_valid())
self.assertEqual(
form.cleaned_data,
{
"availability": ["coming_soon"],
"facet_sorting": "count",
"languages": ["fr"],
"levels": ["1"],
"levels_aggs": [],
"levels_children_aggs": "",
"licences": [],
"licences_aggs": [],
"licences_children_aggs": "",
"limit": 9,
"new": ["new"],
"offset": 3,
"organizations": ["10"],
"organizations_aggs": [],
"organizations_children_aggs": "",
"persons": [],
"persons_aggs": [],
"persons_children_aggs": "",
"query": "maths",
"pace": [],
"scope": "objects",
"subjects": ["1"],
"subjects_aggs": [],
"subjects_children_aggs": "",
},
)
def test_indexers_courses_build_es_query_search_all_courses(self):
"""
Happy path: build a query that does not filter the courses at all
"""
# Build a request stub
request = SimpleNamespace(
query_params=QueryDict(query_string="limit=2&offset=10")
)
self.assertEqual(
CoursesIndexer.build_es_query(request),
(
2,
10,
{"match_all": {}},
{
"all_courses": {
"global": {},
"aggregations": {
"language@en": {
"filter": {
"bool": {"must": [{"term": {"language": "en"}}]}
}
},
"language@fr": {
"filter": {
"bool": {"must": [{"term": {"language": "fr"}}]}
}
},
"organizations": {
"filter": {"bool": {"must": []}},
"aggregations": {
"organizations": {
"terms": {"field": "organizations"}
}
},
},
"subjects": {
"filter": {"bool": {"must": []}},
"aggregations": {
"subjects": {"terms": {"field": "subjects"}}
},
},
},
}
},
),
)
def format_filter(self, obj):
qd = QueryDict(mutable=True)
filter_fields = self.filter.keys()
for field_name in filter_fields:
try:
# check if serializer method passed in
serializer_method = getattr(self.parent, self.filter[field_name])
except AttributeError:
value = self.lookup_attribute(obj, self.filter[field_name])
else:
value = serializer_method(obj)
if not value:
continue
qd.update({'[{}]'.format(field_name): value})
if not qd.keys():
return None
return qd.urlencode(safe=['[', ']'])
