def read_list(self, object_list, bundle): # noqa # too complex
obj_ids = [obj.id for obj in object_list]
if bundle.request.user.is_authenticated() and \
bundle.request.user.is_superuser:
return object_list
if isinstance(bundle.obj, Experiment):
experiments = Experiment.safe.all(bundle.request.user)
return experiments.filter(id__in=obj_ids)
elif isinstance(bundle.obj, ExperimentParameterSet):
experiments = Experiment.safe.all(bundle.request.user)
return ExperimentParameterSet.objects.filter(
experiment__in=experiments, id__in=obj_ids)
elif isinstance(bundle.obj, ExperimentParameter):
experiments = Experiment.safe.all(bundle.request.user)
return ExperimentParameter.objects.filter(
parameterset__experiment__in=experiments,
id__in=obj_ids
)
elif isinstance(bundle.obj, Dataset):
dataset_ids = [ds.id for ds in object_list
if has_dataset_access(bundle.request, ds.id)]
return Dataset.objects.filter(id__in=dataset_ids)
elif isinstance(bundle.obj, DatasetParameterSet):
return [dps for dps in object_list
if has_dataset_access(bundle.request, dps.dataset.id)]
elif isinstance(bundle.obj, DatasetParameter):
return [dp for dp in object_list
if has_dataset_access(bundle.request,
dp.parameterset.dataset.id)]
elif isinstance(bundle.obj, DataFile):
all_files = get_accessible_datafiles_for_user(bundle.request)
return all_files.filter(id__in=obj_ids)
elif isinstance(bundle.obj, DatafileParameterSet):
datafiles = get_accessible_datafiles_for_user(bundle.request)
return DatafileParameterSet.objects.filter(
datafile__in=datafiles, id__in=obj_ids
)
elif isinstance(bundle.obj, DatafileParameter):
datafiles = get_accessible_datafiles_for_user(bundle.request)
return DatafileParameter.objects.filter(
parameterset__datafile__in=datafiles, id__in=obj_ids)
elif isinstance(bundle.obj, Schema):
return object_list
elif isinstance(bundle.obj, ParameterName):
return object_list
elif isinstance(bundle.obj, ObjectACL):
experiment_ids = Experiment.safe.all(
bundle.request.user).values_list('id', flat=True)
return ObjectACL.objects.filter(
content_type__model='experiment',
object_id__in=experiment_ids,
id__in=obj_ids
)
elif bundle.request.user.is_authenticated() and \
isinstance(bundle.obj, User):
if len(facilities_managed_by(bundle.request.user)) > 0:
return object_list
else:
return [user for user in object_list if
(user == bundle.request.user or
user.experiment_set.filter(public_access__gt=1)
.count() > 0)]
elif isinstance(bundle.obj, Group):
if facilities_managed_by(bundle.request.user).count() > 0:
return object_list
else:
return bundle.request.user.groups.filter(id__in=obj_ids)
elif isinstance(bundle.obj, Facility):
facilities = facilities_managed_by(bundle.request.user)
return [facility for facility in object_list
if facility in facilities]
elif isinstance(bundle.obj, Instrument):
facilities = facilities_managed_by(bundle.request.user)
instruments = Instrument.objects.filter(facility__in=facilities)
return [instrument for instrument in object_list
if instrument in instruments]
elif isinstance(bundle.obj, StorageBox):
return object_list
elif isinstance(bundle.obj, StorageBoxOption):
return [option for option in object_list
if option.key in StorageBoxOptionResource.accessible_keys]
elif isinstance(bundle.obj, StorageBoxAttribute):
return object_list
else:
return []
def read_list(self, object_list, bundle): # noqa # too complex
obj_ids = [obj.id for obj in object_list]
if bundle.request.user.is_authenticated() and \
bundle.request.user.is_superuser:
return object_list
if isinstance(bundle.obj, Experiment):
experiments = Experiment.safe.all(bundle.request.user)
return experiments.filter(id__in=obj_ids)
elif isinstance(bundle.obj, ExperimentParameterSet):
experiments = Experiment.safe.all(bundle.request.user)
return ExperimentParameterSet.objects.filter(
experiment__in=experiments, id__in=obj_ids)
elif isinstance(bundle.obj, ExperimentParameter):
experiments = Experiment.safe.all(bundle.request.user)
return ExperimentParameter.objects.filter(
parameterset__experiment__in=experiments, id__in=obj_ids)
elif isinstance(bundle.obj, Dataset):
dataset_ids = [
ds.id for ds in object_list
if has_dataset_access(bundle.request, ds.id)
]
return Dataset.objects.filter(id__in=dataset_ids)
elif isinstance(bundle.obj, DatasetParameterSet):
return [
dps for dps in object_list
if has_dataset_access(bundle.request, dps.dataset.id)
]
elif isinstance(bundle.obj, DatasetParameter):
return [
dp for dp in object_list if has_dataset_access(
bundle.request, dp.parameterset.dataset.id)
]
elif isinstance(bundle.obj, DataFile):
all_files = get_accessible_datafiles_for_user(bundle.request)
return all_files.filter(id__in=obj_ids)
elif isinstance(bundle.obj, DatafileParameterSet):
datafiles = get_accessible_datafiles_for_user(bundle.request)
return DatafileParameterSet.objects.filter(datafile__in=datafiles,
id__in=obj_ids)
elif isinstance(bundle.obj, DatafileParameter):
datafiles = get_accessible_datafiles_for_user(bundle.request)
return DatafileParameter.objects.filter(
parameterset__datafile__in=datafiles, id__in=obj_ids)
elif isinstance(bundle.obj, Schema):
return object_list
elif isinstance(bundle.obj, ParameterName):
return object_list
elif isinstance(bundle.obj, ObjectACL):
experiment_ids = Experiment.safe.all(
bundle.request.user).values_list('id', flat=True)
return ObjectACL.objects.filter(content_type__model='experiment',
object_id__in=experiment_ids,
id__in=obj_ids)
elif bundle.request.user.is_authenticated() and \
isinstance(bundle.obj, User):
if len(facilities_managed_by(bundle.request.user)) > 0:
return object_list
else:
return [
user for user in object_list
if (user == bundle.request.user or user.experiment_set.
filter(public_access__gt=1).count() > 0)
]
elif isinstance(bundle.obj, Group):
if facilities_managed_by(bundle.request.user).count() > 0:
return object_list
else:
return bundle.request.user.groups.filter(id__in=obj_ids)
elif isinstance(bundle.obj, Facility):
facilities = facilities_managed_by(bundle.request.user)
return [
facility for facility in object_list if facility in facilities
]
elif isinstance(bundle.obj, Instrument):
facilities = facilities_managed_by(bundle.request.user)
instruments = Instrument.objects.filter(facility__in=facilities)
return [
instrument for instrument in object_list
if instrument in instruments
]
elif isinstance(bundle.obj, StorageBox):
return object_list
elif isinstance(bundle.obj, StorageBoxOption):
return [
option for option in object_list
if option.key in StorageBoxOptionResource.accessible_keys
]
elif isinstance(bundle.obj, StorageBoxAttribute):
return object_list
else:
return []
def __getFilteredDatafiles(request, searchQueryType, searchFilterData):
"""Filter the list of datafiles for the provided searchQueryType using the
cleaned up searchFilterData.
Arguments:
request -- the HTTP request
searchQueryType -- the type of query, 'mx' or 'saxs'
searchFilterData -- the cleaned up search form data
Returns:
A list of datafiles as a result of the query or None if the provided search
request is invalid
"""
datafile_results = authz.get_accessible_datafiles_for_user(request)
logger.info('__getFilteredDatafiles: searchFilterData {0}'.
format(searchFilterData))
# there's no need to do any filtering if we didn't find any
# datafiles that the user has access to
if not datafile_results:
logger.info("""__getFilteredDatafiles: user {0} doesn\'t have
access to any experiments""".format(request.user))
return datafile_results
q = {
'datafileparameterset__datafileparameter__name__schema__namespace__in':
Schema.getNamespaces(Schema.DATAFILE, searchQueryType)
}
datafile_results = datafile_results.filter(**q).distinct()
# if filename is searchable which i think will always be the case...
if searchFilterData['filename'] != '':
datafile_results = \
datafile_results.filter(
filename__icontains=searchFilterData['filename'])
# TODO: might need to cache the result of this later on
# get all the datafile parameters for the given schema
parameters = [p for p in
ParameterName.objects.filter(
schema__namespace__in=Schema.getNamespaces(
Schema.DATAFILE, searchQueryType))]
datafile_results = __filterParameters(
parameters, datafile_results,
searchFilterData, 'datafileparameterset__datafileparameter')
# get all the dataset parameters for given schema
parameters = [p for p in
ParameterName.objects.filter(
schema__namespace__in=Schema.getNamespaces(
Schema.DATASET, searchQueryType))]
datafile_results = __filterParameters(
parameters, datafile_results,
searchFilterData, 'dataset__datasetparameterset__datasetparameter')
# let's sort it in the end
if datafile_results:
datafile_results = datafile_results.order_by('filename')
logger.debug("results: {0}".format(datafile_results))
return datafile_results
def read_list(self, object_list, bundle):
if bundle.request.user.is_authenticated() and \
bundle.request.user.is_superuser:
return object_list
if type(bundle.obj) == Experiment:
return type(bundle.obj).safe.all(bundle.request.user)
elif type(bundle.obj) == ExperimentParameterSet:
experiments = Experiment.safe.all(bundle.request.user)
eps_list = []
for eps in object_list:
exp = eps.experiment
if exp in experiments:
eps_list.append(eps)
return eps_list
elif type(bundle.obj) == ExperimentParameter:
experiments = Experiment.safe.all(bundle.request.user)
ep_list = []
for ep in object_list:
exp = ep.experiment
if exp in experiments:
ep_list.append(ep)
return eps_list
elif type(bundle.obj) == Dataset:
datasets = []
for ds in object_list:
if has_dataset_access(bundle.request, ds.id):
datasets.append(ds)
return datasets
elif type(bundle.obj) == DatasetParameterSet:
dps_list = []
for dps in object_list:
if has_dataset_access(bundle.request, dps.dataset.id):
dps_list.append(dps)
return dps_list
elif type(bundle.obj) == DatasetParameter:
dp_list = []
for dp in object_list:
if has_dataset_access(bundle.request,
dp.parameterset.dataset.id):
dp_list.append(dp)
return dp_list
elif type(bundle.obj) == Dataset_File:
all_dfs = set(
get_accessible_datafiles_for_user(bundle.request))
return list(all_dfs.intersection(object_list))
elif type(bundle.obj) == DatafileParameterSet:
datafiles = get_accessible_datafiles_for_user(bundle.request)
dfps_list = []
for dfps in object_list:
if dfps.dataset_file in datafiles:
dfps_list.append(dfps)
return dfps_list
elif type(bundle.obj) == DatafileParameter:
datafiles = get_accessible_datafiles_for_user(bundle.request)
dfp_list = []
for dfp in object_list:
if dfp.parameterset.dataset_file in datafiles:
dfp_list.append(dfp)
return dfp_list
else:
return []
def __getFilteredDatafiles(request, searchQueryType, searchFilterData):
"""Filter the list of datafiles for the provided searchQueryType using the
cleaned up searchFilterData.
Arguments:
request -- the HTTP request
searchQueryType -- the type of query, 'mx' or 'saxs'
searchFilterData -- the cleaned up search form data
Returns:
list: A list of datafiles as a result of the query or None if the
provided search request is invalid
"""
datafile_results = authz.get_accessible_datafiles_for_user(request)
logger.info('__getFilteredDatafiles: searchFilterData {0}'.
format(searchFilterData))
# there's no need to do any filtering if we didn't find any
# datafiles that the user has access to
if not datafile_results:
logger.info("""__getFilteredDatafiles: user {0} doesn\'t have
access to any experiments""".format(request.user))
return datafile_results
q = {
'datafileparameterset__datafileparameter__name__schema__namespace__in':
Schema.getNamespaces(Schema.DATAFILE, searchQueryType)
}
datafile_results = datafile_results.filter(**q).distinct()
# if filename is searchable which i think will always be the case...
if searchFilterData['filename'] != '':
datafile_results = \
datafile_results.filter(
filename__icontains=searchFilterData['filename'])
# TODO: might need to cache the result of this later on
# get all the datafile parameters for the given schema
parameters = [p for p in
ParameterName.objects.filter(
schema__namespace__in=Schema.getNamespaces(
Schema.DATAFILE, searchQueryType))]
datafile_results = __filterParameters(
parameters, datafile_results,
searchFilterData, 'datafileparameterset__datafileparameter')
# get all the dataset parameters for given schema
parameters = [p for p in
ParameterName.objects.filter(
schema__namespace__in=Schema.getNamespaces(
Schema.DATASET, searchQueryType))]
datafile_results = __filterParameters(
parameters, datafile_results,
searchFilterData, 'dataset__datasetparameterset__datasetparameter')
# let's sort it in the end
if datafile_results:
datafile_results = datafile_results.order_by('filename')
logger.debug("results: {0}".format(datafile_results))
return datafile_results
