def case_owners(self):
# Get user ids for each user that match the demo_user, admin,
# Unknown Users, or All Mobile Workers filters
mobile_user_and_group_slugs = self.request.GET.getlist(EMWF.slug)
user_types = EMWF.selected_user_types(mobile_user_and_group_slugs)
special_owner_ids = self.get_special_owner_ids(
admin=HQUserType.ADMIN in user_types,
unknown=HQUserType.UNKNOWN in user_types,
demo=HQUserType.DEMO_USER in user_types,
commtrack=HQUserType.COMMTRACK in user_types,
)
# Get user ids for each user that was specifically selected
selected_user_ids = EMWF.selected_user_ids(mobile_user_and_group_slugs)
# Get group ids for each group that was specified
selected_reporting_group_ids = EMWF.selected_reporting_group_ids(
mobile_user_and_group_slugs)
selected_sharing_group_ids = EMWF.selected_sharing_group_ids(
mobile_user_and_group_slugs)
# Show cases owned by any selected locations, user locations, or their children
loc_ids = set(
EMWF.selected_location_ids(mobile_user_and_group_slugs) +
get_users_location_ids(self.domain, selected_user_ids))
location_owner_ids = get_locations_and_children(loc_ids).location_ids()
# Get user ids for each user in specified reporting groups
report_group_q = HQESQuery(index="groups").domain(self.domain)\
.doc_type("Group")\
.filter(filters.term("_id", selected_reporting_group_ids))\
.fields(["users"])
user_lists = [group["users"] for group in report_group_q.run().hits]
selected_reporting_group_users = list(set().union(*user_lists))
# Get ids for each sharing group that contains a user from selected_reporting_group_users OR a user that was specifically selected
share_group_q = (HQESQuery(index="groups").domain(
self.domain).doc_type("Group").term("case_sharing", True).term(
"users",
(selected_reporting_group_users + selected_user_ids)).fields(
[]))
sharing_group_ids = share_group_q.run().doc_ids
owner_ids = list(set().union(
special_owner_ids,
selected_user_ids,
selected_sharing_group_ids,
selected_reporting_group_users,
sharing_group_ids,
location_owner_ids,
))
return owner_ids
def case_owners(self):
# Get user ids for each user that match the demo_user, admin,
# Unknown Users, or All Mobile Workers filters
mobile_user_and_group_slugs = self.request.GET.getlist(EMWF.slug)
user_types = EMWF.selected_user_types(mobile_user_and_group_slugs)
special_owner_ids = self.get_special_owner_ids(
admin=HQUserType.ADMIN in user_types,
unknown=HQUserType.UNKNOWN in user_types,
demo=HQUserType.DEMO_USER in user_types,
commtrack=HQUserType.COMMTRACK in user_types,
)
# Get user ids for each user that was specifically selected
selected_user_ids = EMWF.selected_user_ids(mobile_user_and_group_slugs)
# Get group ids for each group that was specified
selected_reporting_group_ids = EMWF.selected_reporting_group_ids(mobile_user_and_group_slugs)
selected_sharing_group_ids = EMWF.selected_sharing_group_ids(mobile_user_and_group_slugs)
# Show cases owned by any selected locations, user locations, or their children
loc_ids = set(EMWF.selected_location_ids(mobile_user_and_group_slugs) +
get_users_location_ids(self.domain, selected_user_ids))
location_owner_ids = get_locations_and_children(loc_ids).location_ids()
# Get user ids for each user in specified reporting groups
report_group_q = HQESQuery(index="groups").domain(self.domain)\
.doc_type("Group")\
.filter(filters.term("_id", selected_reporting_group_ids))\
.fields(["users"])
user_lists = [group["users"] for group in report_group_q.run().hits]
selected_reporting_group_users = list(set().union(*user_lists))
# Get ids for each sharing group that contains a user from selected_reporting_group_users OR a user that was specifically selected
share_group_q = (HQESQuery(index="groups")
.domain(self.domain)
.doc_type("Group")
.term("case_sharing", True)
.term("users", (selected_reporting_group_users +
selected_user_ids))
.fields([]))
sharing_group_ids = share_group_q.run().doc_ids
owner_ids = list(set().union(
special_owner_ids,
selected_user_ids,
selected_sharing_group_ids,
selected_reporting_group_users,
sharing_group_ids,
location_owner_ids,
))
return owner_ids
def _to_case_export_instance_filters(self, can_access_all_locations,
accessible_location_ids):
emwf_selections = self.cleaned_data["emwf_case_filter"]
return CaseExportInstanceFilters(
date_period=DatePeriod(
period_type=self.cleaned_data['date_range'],
days=self.cleaned_data['days'],
begin=self.cleaned_data['start_date'],
end=self.cleaned_data['end_date'],
),
users=CaseListFilter.selected_user_ids(emwf_selections),
reporting_groups=CaseListFilter.selected_reporting_group_ids(
emwf_selections),
locations=CaseListFilter.selected_location_ids(emwf_selections),
user_types=CaseListFilter.selected_user_types(emwf_selections),
can_access_all_locations=can_access_all_locations,
accessible_location_ids=accessible_location_ids,
sharing_groups=CaseListFilter.selected_sharing_group_ids(
emwf_selections),
show_all_data=CaseListFilter.show_all_data(emwf_selections)
or CaseListFilter.no_filters_selected(emwf_selections),
show_project_data=CaseListFilter.show_project_data(
emwf_selections),
)
def _build_query(self):
query = (self.search_class()
.domain(self.domain)
.size(self.pagination.count)
.start(self.pagination.start))
query.es_query['sort'] = self.get_sorting_block()
mobile_user_and_group_slugs = self.request.GET.getlist(EMWF.slug)
user_types = EMWF.selected_user_types(mobile_user_and_group_slugs)
if self.case_filter:
query = query.filter(self.case_filter)
query = query.NOT(case_es.case_type("user-owner-mapping-case"))
if self.case_type:
query = query.case_type(self.case_type)
if self.case_status:
query = query.is_closed(self.case_status == 'closed')
if self.request.can_access_all_locations and (EMWF.show_all_data(mobile_user_and_group_slugs) or
EMWF.no_filters_selected(mobile_user_and_group_slugs)):
pass
elif self.request.can_access_all_locations and EMWF.show_project_data(mobile_user_and_group_slugs):
# Show everything but stuff we know for sure to exclude
ids_to_exclude = self.get_special_owner_ids(
admin=HQUserType.ADMIN not in user_types,
unknown=HQUserType.UNKNOWN not in user_types,
web=HQUserType.WEB not in user_types,
demo=HQUserType.DEMO_USER not in user_types,
commtrack=False,
)
query = query.NOT(case_es.owner(ids_to_exclude))
elif self.request.can_access_all_locations and EMWF.show_deactivated_data(mobile_user_and_group_slugs):
owner_ids = (user_es.UserES()
.show_only_inactive()
.domain(self.domain)
.get_ids())
query = query.OR(case_es.owner(owner_ids))
else: # Only show explicit matches
query = query.owner(self.case_owners)
if not self.request.can_access_all_locations:
query = query.OR(self.scope_filter())
search_string = CaseSearchFilter.get_value(self.request, self.domain)
if search_string:
query = query.set_query({"query_string": {"query": search_string}})
return query
def _build_query(self):
query = (self.search_class().domain(self.domain).size(
self.pagination.count).start(self.pagination.start))
query.es_query['sort'] = self.get_sorting_block()
mobile_user_and_group_slugs = self.request.GET.getlist(EMWF.slug)
user_types = EMWF.selected_user_types(mobile_user_and_group_slugs)
if self.case_filter:
query = query.filter(self.case_filter)
query = query.NOT(case_es.case_type("user-owner-mapping-case"))
if self.case_type:
query = query.case_type(self.case_type)
if self.case_status:
query = query.is_closed(self.case_status == 'closed')
if self.request.can_access_all_locations and (
EMWF.show_all_data(mobile_user_and_group_slugs)
or EMWF.no_filters_selected(mobile_user_and_group_slugs)):
pass
elif self.request.can_access_all_locations and EMWF.show_project_data(
mobile_user_and_group_slugs):
# Show everything but stuff we know for sure to exclude
ids_to_exclude = self.get_special_owner_ids(
admin=HQUserType.ADMIN not in user_types,
unknown=HQUserType.UNKNOWN not in user_types,
web=HQUserType.WEB not in user_types,
demo=HQUserType.DEMO_USER not in user_types,
commtrack=False,
)
query = query.NOT(case_es.owner(ids_to_exclude))
elif self.request.can_access_all_locations and EMWF.show_deactivated_data(
mobile_user_and_group_slugs):
owner_ids = (user_es.UserES().show_only_inactive().domain(
self.domain).get_ids())
query = query.OR(case_es.owner(owner_ids))
else: # Only show explicit matches
query = query.owner(self.case_owners)
if not self.request.can_access_all_locations:
query = query.OR(self.scope_filter())
search_string = CaseSearchFilter.get_value(self.request, self.domain)
if search_string:
query = query.set_query({"query_string": {"query": search_string}})
return query
def get_filtered_query(self, query):
if self.request.can_access_all_locations and (EMWF.show_all_data(
self.value) or EMWF.no_filters_selected(self.value)):
return query
if self.request.can_access_all_locations and EMWF.show_project_data(
self.value):
return query_all_project_data(query, self.domain, self.value)
if self.request.can_access_all_locations and EMWF.show_deactivated_data(
self.value):
return query_deactivated_data(query, self.domain)
# otherwise only return explicit matches
case_owners = get_case_owners(self.request, self.domain, self.value)
return query.owner(case_owners)
def get_filtered_query(self, query):
if self.request.can_access_all_locations and (
EMWF.show_all_data(self.value)
or EMWF.no_filters_selected(self.value)
):
return query
if self.request.can_access_all_locations and EMWF.show_project_data(self.value):
return query.filter(all_project_data_filter(self.domain, self.value))
if self.request.can_access_all_locations and EMWF.show_deactivated_data(self.value):
return query.filter(deactivated_case_owners(self.domain))
selected_user_types = [v['id'] for v in self.value]
case_owners = get_case_owners(self.request, self.domain, selected_user_types)
return query.owner(case_owners)
def location_sharing_owner_ids(self):
"""
For now (and hopefully for always) the only owner
id that is important for case sharing group selection
is that actual group id.
"""
return EMWF.selected_sharing_location_ids(self.request)
def get_filtered_query(self, query):
if self.request.can_access_all_locations and (
EMWF.show_all_data(self.value)
or EMWF.no_filters_selected(self.value)
):
return query
if self.request.can_access_all_locations and EMWF.show_project_data(self.value):
return query_all_project_data(query, self.domain, self.value)
if self.request.can_access_all_locations and EMWF.show_deactivated_data(self.value):
return query_deactivated_data(query, self.domain)
# otherwise only return explicit matches
case_owners = get_case_owners(self.request, self.domain, self.value)
return query.owner(case_owners)
def _build_query(self):
query = (self.search_class()
.domain(self.domain)
.size(self.pagination.count)
.start(self.pagination.start))
query.es_query['sort'] = self.get_sorting_block()
mobile_user_and_group_slugs = self.request.GET.getlist(EMWF.slug)
if self.case_filter:
query = query.filter(self.case_filter)
query = query.NOT(case_es.case_type("user-owner-mapping-case"))
if self.case_type:
query = query.case_type(self.case_type)
if self.case_status:
query = query.is_closed(self.case_status == 'closed')
if self.request.can_access_all_locations and (
EMWF.show_all_data(mobile_user_and_group_slugs)
or EMWF.no_filters_selected(mobile_user_and_group_slugs)
):
pass
elif (self.request.can_access_all_locations
and EMWF.show_project_data(mobile_user_and_group_slugs)):
query = query_all_project_data(
query, self.domain, mobile_user_and_group_slugs
)
elif (self.request.can_access_all_locations
and EMWF.show_deactivated_data(mobile_user_and_group_slugs)):
query = query_deactivated_data(query, self.domain)
else: # Only show explicit matches
query = query.owner(self.case_owners)
if not self.request.can_access_all_locations:
query = query_location_restricted_cases(query, self.request)
search_string = CaseSearchFilter.get_value(self.request, self.domain)
if search_string:
query = query.set_query({"query_string": {"query": search_string}})
return query
def _build_query(self):
query = (self.search_class()
.domain(self.domain)
.size(self.pagination.count)
.start(self.pagination.start))
query.es_query['sort'] = self.get_sorting_block()
mobile_user_and_group_slugs = self.request.GET.getlist(EMWF.slug)
if self.case_filter:
query = query.filter(self.case_filter)
query = query.NOT(case_es.case_type("user-owner-mapping-case"))
if self.case_type:
query = query.case_type(self.case_type)
if self.case_status:
query = query.is_closed(self.case_status == 'closed')
if self.request.can_access_all_locations and (
EMWF.show_all_data(mobile_user_and_group_slugs)
or EMWF.no_filters_selected(mobile_user_and_group_slugs)
):
pass
elif (self.request.can_access_all_locations
and EMWF.show_project_data(mobile_user_and_group_slugs)):
query = query_all_project_data(
query, self.domain, mobile_user_and_group_slugs
)
elif (self.request.can_access_all_locations
and EMWF.show_deactivated_data(mobile_user_and_group_slugs)):
query = query_deactivated_data(query, self.domain)
else: # Only show explicit matches
query = query.owner(self.case_owners)
if not self.request.can_access_all_locations:
query = query_location_restricted_cases(query, self.request)
search_string = CaseSearchFilter.get_value(self.request, self.domain)
if search_string:
query = query.set_query({"query_string": {"query": search_string}})
return query
def query_all_project_data(query, domain, mobile_user_and_group_slugs):
# Show everything but stuff we know for sure to exclude
user_types = EMWF.selected_user_types(mobile_user_and_group_slugs)
ids_to_exclude = _get_special_owner_ids(
domain=domain,
admin=HQUserType.ADMIN not in user_types,
unknown=HQUserType.UNKNOWN not in user_types,
web=HQUserType.WEB not in user_types,
demo=HQUserType.DEMO_USER not in user_types,
commtrack=False,
)
return query.NOT(case_es.owner(ids_to_exclude))
def query_all_project_data(query, domain, mobile_user_and_group_slugs):
# Show everything but stuff we know for sure to exclude
user_types = EMWF.selected_user_types(mobile_user_and_group_slugs)
ids_to_exclude = _get_special_owner_ids(
domain=domain,
admin=HQUserType.ADMIN not in user_types,
unknown=HQUserType.UNKNOWN not in user_types,
web=HQUserType.WEB not in user_types,
demo=HQUserType.DEMO_USER not in user_types,
commtrack=False,
)
return query.NOT(case_es.owner(ids_to_exclude))
def _build_query(self):
query = (case_es.CaseES()
.domain(self.domain)
.size(self.pagination.count)
.start(self.pagination.start))
query.es_query['sort'] = self.get_sorting_block()
if self.case_filter:
query = query.filter(self.case_filter)
query = query.NOT(case_es.case_type("user-owner-mapping-case"))
if self.case_type:
query = query.case_type(self.case_type)
if self.case_status:
query = query.is_closed(self.case_status == 'closed')
if EMWF.show_all_data(self.request):
pass
elif EMWF.show_project_data(self.request):
# Show everything but stuff we know for sure to exclude
user_types = EMWF.selected_user_types(self.request)
ids_to_exclude = self.get_special_owner_ids(
admin=HQUserType.ADMIN not in user_types,
unknown=HQUserType.UNKNOWN not in user_types,
demo=HQUserType.DEMO_USER not in user_types,
commtrack=False,
)
query = query.NOT(case_es.owner(ids_to_exclude))
else: # Only show explicit matches
query = query.owner(self.case_owners)
search_string = SearchFilter.get_value(self.request, self.domain)
if search_string:
query = query.set_query({"query_string": {"query": search_string}})
return query
def _build_query(self):
query = (case_es.CaseES()
.domain(self.domain)
.size(self.pagination.count)
.start(self.pagination.start))
query.es_query['sort'] = self.get_sorting_block()
if self.case_filter:
query = query.filter(self.case_filter)
query = query.NOT(case_es.case_type("user-owner-mapping-case"))
if self.case_type:
query = query.case_type(self.case_type)
if self.case_status:
query = query.is_closed(self.case_status == 'closed')
if EMWF.show_all_data(self.request):
pass
elif EMWF.show_project_data(self.request):
# Show everything but stuff we know for sure to exclude
user_types = EMWF.selected_user_types(self.request)
ids_to_exclude = self.get_special_owner_ids(
admin=HQUserType.ADMIN not in user_types,
unknown=HQUserType.UNKNOWN not in user_types,
demo=HQUserType.DEMO_USER not in user_types,
commtrack=False,
)
query = query.NOT(case_es.owner(ids_to_exclude))
else: # Only show explicit matches
query = query.owner(self.case_owners)
search_string = SearchFilter.get_value(self.request, self.domain)
if search_string:
query = query.set_query({"query_string": {"query": search_string}})
return query
def location_reporting_owner_ids(self):
"""
Include all users that are assigned to the selected
locations or those locations descendants.
"""
from corehq.apps.locations.models import SQLLocation, LOCATION_REPORTING_PREFIX
results = []
selected_location_group_ids = EMWF.selected_location_reporting_group_ids(self.request)
for group_id in selected_location_group_ids:
loc = SQLLocation.objects.get(
location_id=group_id.replace(LOCATION_REPORTING_PREFIX, '')
)
for l in loc.get_descendants(include_self=True):
results += get_user_ids_by_location(l.location_id)
return results
def _to_case_export_instance_filters(self, can_access_all_locations, accessible_location_ids):
emwf_selections = [x['id'] for x in self.cleaned_data["emwf_case_filter"]]
return CaseExportInstanceFilters(
date_period=DatePeriod(
period_type=self.cleaned_data['date_range'],
days=self.cleaned_data['days'],
begin=self.cleaned_data['start_date'],
end=self.cleaned_data['end_date'],
),
users=CaseListFilter.selected_user_ids(emwf_selections),
reporting_groups=CaseListFilter.selected_reporting_group_ids(emwf_selections),
locations=CaseListFilter.selected_location_ids(emwf_selections),
user_types=CaseListFilter.selected_user_types(emwf_selections),
can_access_all_locations=can_access_all_locations,
accessible_location_ids=accessible_location_ids,
sharing_groups=CaseListFilter.selected_sharing_group_ids(emwf_selections),
show_all_data=CaseListFilter.show_all_data(emwf_selections) or
CaseListFilter.no_filters_selected(emwf_selections),
show_project_data=CaseListFilter.show_project_data(emwf_selections),
)
def get_case_owners(request, domain, mobile_user_and_group_slugs):
"""
For unrestricted user
:return:
user ids for selected user types
for selected reporting group ids, returns user_ids belonging to these groups
also finds the sharing groups which has any user from the above reporting group
selected sharing group ids
selected user ids
also finds the sharing groups which has any user from the above selected users
ids and descendants ids of assigned locations to these users
ids and descendants ids of selected locations
assigned users at selected locations and their descendants
For restricted user
:return:
selected user ids
also finds the sharing groups which has any user from the above selected users
ids and descendants ids of assigned locations to these users
ids and descendants ids of selected locations
assigned users at selected locations and their descendants
"""
special_owner_ids, selected_sharing_group_ids, selected_reporting_group_users = [], [], []
sharing_group_ids, location_owner_ids, assigned_user_ids_at_selected_locations = [], [], []
if request.can_access_all_locations:
user_types = EMWF.selected_user_types(mobile_user_and_group_slugs)
special_owner_ids = _get_special_owner_ids(
domain=domain,
admin=HQUserType.ADMIN in user_types,
unknown=HQUserType.UNKNOWN in user_types,
web=HQUserType.WEB in user_types,
demo=HQUserType.DEMO_USER in user_types,
commtrack=HQUserType.COMMTRACK in user_types,
)
# Get group ids for each group that was specified
selected_reporting_group_ids = EMWF.selected_reporting_group_ids(
mobile_user_and_group_slugs)
selected_sharing_group_ids = EMWF.selected_sharing_group_ids(
mobile_user_and_group_slugs)
# Get user ids for each user in specified reporting groups
selected_reporting_group_users = []
if selected_reporting_group_ids:
report_group_q = (HQESQuery(
index="groups").domain(domain).doc_type("Group").filter(
filters.term("_id", selected_reporting_group_ids)).fields(
["users"]))
user_lists = [
group["users"] for group in report_group_q.run().hits
]
selected_reporting_group_users = list(set().union(*user_lists))
# Get user ids for each user that was specifically selected
selected_user_ids = EMWF.selected_user_ids(mobile_user_and_group_slugs)
# Show cases owned by any selected locations, user locations, or their children
loc_ids = set(EMWF.selected_location_ids(mobile_user_and_group_slugs))
if loc_ids:
# Get users at selected locations and descendants
assigned_user_ids_at_selected_locations = user_ids_at_locations_and_descendants(
loc_ids)
# Get user ids for each user in specified reporting groups
if selected_user_ids:
loc_ids.update(get_users_location_ids(domain, selected_user_ids))
location_owner_ids = []
if loc_ids:
location_owner_ids = SQLLocation.objects.get_locations_and_children_ids(
loc_ids)
sharing_group_ids = []
if selected_reporting_group_users or selected_user_ids:
# Get ids for each sharing group that contains a user from
# selected_reporting_group_users OR a user that was specifically selected
sharing_group_ids = (HQESQuery(
index="groups").domain(domain).doc_type("Group").term(
"case_sharing", True).term("users",
(selected_reporting_group_users +
selected_user_ids)).get_ids())
owner_ids = list(set().union(
special_owner_ids,
selected_user_ids,
selected_sharing_group_ids,
selected_reporting_group_users,
sharing_group_ids,
location_owner_ids,
assigned_user_ids_at_selected_locations,
))
return owner_ids
def case_owners(self):
"""
For unrestricted user
:return:
user ids for selected user types
for selected reporting group ids, returns user_ids belonging to these groups
also finds the sharing groups which has any user from the above reporting group
selected sharing group ids
selected user ids
also finds the sharing groups which has any user from the above selected users
ids and descendants ids of assigned locations to these users
ids and descendants ids of selected locations
assigned users at selected locations and their descendants
For restricted user
:return:
selected user ids
also finds the sharing groups which has any user from the above selected users
ids and descendants ids of assigned locations to these users
ids and descendants ids of selected locations
assigned users at selected locations and their descendants
"""
# Get user ids for each user that match the demo_user, admin,
# Unknown Users, or All Mobile Workers filters
mobile_user_and_group_slugs = self.request.GET.getlist(EMWF.slug)
special_owner_ids, selected_sharing_group_ids, selected_reporting_group_users = [], [], []
sharing_group_ids, location_owner_ids, assigned_user_ids_at_selected_locations = [], [], []
if self.request.can_access_all_locations:
user_types = EMWF.selected_user_types(mobile_user_and_group_slugs)
special_owner_ids = self.get_special_owner_ids(
admin=HQUserType.ADMIN in user_types,
unknown=HQUserType.UNKNOWN in user_types,
web=HQUserType.WEB in user_types,
demo=HQUserType.DEMO_USER in user_types,
commtrack=HQUserType.COMMTRACK in user_types,
)
# Get group ids for each group that was specified
selected_reporting_group_ids = EMWF.selected_reporting_group_ids(mobile_user_and_group_slugs)
selected_sharing_group_ids = EMWF.selected_sharing_group_ids(mobile_user_and_group_slugs)
# Get user ids for each user in specified reporting groups
selected_reporting_group_users = []
if selected_reporting_group_ids:
report_group_q = (HQESQuery(index="groups").domain(self.domain)
.doc_type("Group")
.filter(filters.term("_id", selected_reporting_group_ids))
.fields(["users"]))
user_lists = [group["users"] for group in report_group_q.run().hits]
selected_reporting_group_users = list(set().union(*user_lists))
# Get user ids for each user that was specifically selected
selected_user_ids = EMWF.selected_user_ids(mobile_user_and_group_slugs)
# Show cases owned by any selected locations, user locations, or their children
loc_ids = set(EMWF.selected_location_ids(mobile_user_and_group_slugs))
if loc_ids:
# Get users at selected locations and descendants
assigned_user_ids_at_selected_locations = user_ids_at_locations_and_descendants(loc_ids)
# Get user ids for each user in specified reporting groups
if selected_user_ids:
loc_ids.update(get_users_location_ids(self.domain, selected_user_ids))
location_owner_ids = []
if loc_ids:
location_owner_ids = SQLLocation.objects.get_locations_and_children_ids(loc_ids)
sharing_group_ids = []
if selected_reporting_group_users or selected_user_ids:
# Get ids for each sharing group that contains a user from selected_reporting_group_users
# OR a user that was specifically selected
sharing_group_ids = (HQESQuery(index="groups")
.domain(self.domain)
.doc_type("Group")
.term("case_sharing", True)
.term("users", (selected_reporting_group_users +
selected_user_ids))
.get_ids())
owner_ids = list(set().union(
special_owner_ids,
selected_user_ids,
selected_sharing_group_ids,
selected_reporting_group_users,
sharing_group_ids,
location_owner_ids,
assigned_user_ids_at_selected_locations,
))
return owner_ids
