def __call__(self, version=None, include_items=True):
result = super(SerializeCollectionToJson,
self).__call__(version=version)
include_items = self.request.form.get("include_items", include_items)
include_items = boolean_value(include_items)
if include_items:
results = self.context.results(batch=False)
batch = HypermediaBatch(self.request, results)
if not self.request.form.get("fullobjects"):
result["@id"] = batch.canonical_url
result["items_total"] = batch.items_total
if batch.links:
result["batching"] = batch.links
if "fullobjects" in list(self.request.form):
result["items"] = [
getMultiAdapter((brain.getObject(), self.request),
ISerializeToJson)() for brain in batch
]
else:
result["items"] = [
getMultiAdapter((brain, self.request),
ISerializeToJsonSummary)()
for brain in batch
]
return result
def get_param(value, default=False, extra_include_name=None, serializer=None):
"""If current serialized element is an extra_include,
infos in request.form are relative to extra_include,
else information are directly available.
For extra_include, a parameter is passed like :
?extra_include=extra_include_name:parameter_name:value so
?extra_include_category_include_all=false."""
request = getRequest()
# extra_include_name is stored on serializer or passed as parameter when serializer
# still not initialized, this is the case for parameter "fullobjects" as from this
# will depend the interface to use to get the serializer
extra_include_name = serializer and \
getattr(serializer, "_extra_include_name", extra_include_name)
if extra_include_name:
# change param value
value = "extra_include_{0}_{1}".format(extra_include_name, value)
param = request.form.get(value, None)
# param was not found in request.form
if param is None:
param = default
elif default in (True, False):
param = boolean_value(param)
return param
def __call__(self, version=None, include_items=True):
folder_metadata = super(SerializeFolderToJson,
self).__call__(version=version)
folder_metadata.update({'is_folderish': True})
result = folder_metadata
include_items = self.request.form.get('include_items', include_items)
include_items = boolean_value(include_items)
if include_items:
query = self._build_query()
catalog = getToolByName(self.context, 'portal_catalog')
brains = catalog(query)
batch = HypermediaBatch(self.request, brains)
if not self.request.form.get('fullobjects'):
result['@id'] = batch.canonical_url
result['items_total'] = batch.items_total
if batch.links:
result['batching'] = batch.links
result['items'] = [
getMultiAdapter((brain, self.request),
ISerializeToJsonSummary)() for brain in batch
]
return result
def reply(self):
obj = _get_obj_from_uid(self.uid)
self.context = obj
self._check_obj()
# set include_items=False by default in request
if not self.request.form.get("include_items", None):
self.request.form["include_items"] = False
# boolean_value of "" is True
fullobjects = boolean_value(self.request.form.get(
"fullobjects", False))
if fullobjects:
serializer = queryMultiAdapter((self.context, self.request),
ISerializeToJson)
else:
serializer = queryMultiAdapter((self.context, self.request),
ISerializeToJsonSummary)
if serializer is None:
self.request.response.setStatus(501)
return dict(error=dict(message="No serializer available."))
if fullobjects:
return serializer(version=self.request.get("version"))
else:
return serializer()
def __call__(self, version=None, include_items=True):
folder_metadata = super(SerializeFolderToJson, self).__call__(version=version)
folder_metadata.update({"is_folderish": True})
result = folder_metadata
include_items = self.request.form.get("include_items", include_items)
include_items = boolean_value(include_items)
if include_items:
query = self._build_query()
catalog = getToolByName(self.context, "portal_catalog")
brains = catalog(query)
batch = HypermediaBatch(self.request, brains)
if not self.request.form.get("fullobjects"):
result["@id"] = batch.canonical_url
result["items_total"] = batch.items_total
if batch.links:
result["batching"] = batch.links
if "fullobjects" in list(self.request.form):
result["items"] = getMultiAdapter(
(brains, self.request), ISerializeToJson
)(fullobjects=True)["items"]
else:
result["items"] = [
getMultiAdapter((brain, self.request), ISerializeToJsonSummary)()
for brain in batch
]
return result
def _set_query_meetings_accepting_items(self):
""" """
query = {}
form = self.request.form
if self.type == "meeting" and boolean_value(
form.get("meetings_accepting_items", False)):
query.update(self.cfg._getMeetingsAcceptingItemsQuery())
return query
def values(self):
if not self._values:
self._values = {
k.lower(): boolean_value(os.getenv(k, default)) if isinstance(
default, bool) else os.getenv(k, default)
for k, default in self._env_keys.items()
}
return self._values
def serialize_extra_include_annexes(result, serializer):
""" """
# compute filters to get annexes
filters = {}
for filter_value in ANNEXES_FILTER_VALUES:
value = serializer._get_param(filter_value,
default=None,
extra_include_name="annexes")
if value is not None:
filters[filter_value] = boolean_value(value)
result["extra_include_annexes"] = serialize_annexes(
serializer.context, filters, "annexes", serializer)
return result
def _stats(self):
""" """
include_stats = self.request.form.get("include_stats", False)
stats = {}
if boolean_value(include_stats):
user = api.user.get_current()
if not user.has_role("Manager"):
raise Unauthorized(STATS_UNAUTHORIZED)
# all this was gently borrowed from imio.updates inst_infos.py
stats["users"] = self._stats_users()
stats["groups"] = self._stats_groups()
stats["types"] = self._stats_types()
stats["database"] = self._stats_database()
return stats
def search(self, query=None):
if query is None:
solr_query = {}
else:
solr_query = deepcopy(query)
fl = self.get_fields_list(solr_query)
facets = boolean_value(solr_query.get("facets", False))
facet_fields = solr_query.get("facet_fields", [])
query_params = {"fl": fl}
if facets:
query_params["facets"] = facets
if facet_fields:
query_params["facet_fields"] = facet_fields
del solr_query["facet_fields"]
if "facets" in solr_query:
del solr_query["facets"]
query_params["query"] = solr_query
return self.serialize_results(solr_search(**query_params))
def __call__(self, expand=False):
result = {
"annexes": {
"@id": "{}/@annexes".format(self.context.absolute_url())
}
}
if not expand:
return result
# extend batch? DEFAULT_BATCH_SIZE = 25
# self.request.form['b_size'] = 50
# get filters from request.form
# it is possible to filter annexes on every boolean attributes :
# to_print, confidential, publishable, to_sign/signed
filters = {
k: boolean_value(v)
for k, v in self.request.form.items() if k in ANNEXES_FILTER_VALUES
}
result = serialize_annexes(self.context, filters)
return result
def test_false_int(self):
self.assertFalse(boolean_value(0))
def __call__(self, object_uid, redirect=True):
""" """
if not self.context._mayChangeAttendees():
raise Unauthorized
# redirect can by passed by jQuery, in this case, we receive '0' or '1'
redirect = boolean_value(redirect)
vote_number = int(object_uid)
item_uid = self.context.UID()
meeting = self.context.getMeeting()
if item_uid in meeting.item_votes:
item_votes = meeting.item_votes[item_uid]
assert self.context._voteIsDeletable(vote_number)
vote_to_delete = item_votes[vote_number]
if self.context.get_votes_are_secret():
originnal_vote_keys = [
str(vote_count) for vote_value, vote_count in
vote_to_delete['votes'].items()
]
originnal_vote_keys = "__".join(originnal_vote_keys)
originnal_vote_values = [
vote_value for vote_value, vote_count in
vote_to_delete['votes'].items()
]
originnal_vote_values = "__".join(originnal_vote_values)
fp_extras_pattern = 'item={0} vote_number={1} vote_label={2} vote_count={3} vote_values={4}'
else:
originnal_vote_keys = [
voter_uid for voter_uid in vote_to_delete['voters']
]
originnal_vote_keys = "__".join(originnal_vote_keys)
originnal_vote_values = [
vote_value
for vote_value in vote_to_delete['voters'].values()
]
originnal_vote_values = "__".join(originnal_vote_values)
fp_extras_pattern = 'item={0} vote_number={1} vote_label={2} voter_uids={3} vote_values={4}'
# call clean_voters_linked_to with every values NOT_ENCODED_VOTE_VALUE
# to liberate every values
new_voters = vote_to_delete['voters'].copy()
new_voters = {
voter_uid: NOT_ENCODED_VOTE_VALUE
for voter_uid, vote_value in new_voters.items()
if vote_value != NOT_VOTABLE_LINKED_TO_VALUE
}
clean_voters_linked_to(self.context, meeting, vote_number,
new_voters)
# delete from meeting itemVote
deleted_vote = meeting.item_votes[item_uid].pop(vote_number)
# if deleted last existing vote (vote_number 0) remove context UID from meeting itemVotes
if not meeting.item_votes[item_uid]:
del meeting.item_votes[item_uid]
# finish deletion
label = deleted_vote['label'] or ""
extras = fp_extras_pattern.format(repr(self.context), vote_number,
label.encode('utf-8'),
originnal_vote_keys,
originnal_vote_values)
fplog('delete_item_votes', extras=extras)
# message
api.portal.show_message(_(
"Votes number ${vote_number} have been deleted for current item.",
mapping={'vote_number': vote_number + 1}),
request=self.request)
self._finished = True
def test_false_string(self):
self.assertFalse(boolean_value("false"))
def test_true_bool(self):
self.assertTrue(boolean_value(True))
def test_true_string(self):
self.assertTrue(boolean_value('true'))
def test_true_string_uppercase(self):
self.assertTrue(boolean_value('True'))
def test_true_int_string(self):
self.assertTrue(boolean_value('1'))
def test_true_int(self):
self.assertTrue(boolean_value(1))
def test_true_other_value(self):
self.assertTrue(boolean_value('foobar'))
def test_false_int_string(self):
self.assertFalse(boolean_value('0'))
def get_return_fullobject_after_creation_default():
""" Return the return_fullobject_after_creation_default defined in instance config """
return boolean_value(
os.getenv("RETURN_FULLOBJECT_AFTER_CREATION_DEFAULT", True))
def test_false_string_uppercase(self):
self.assertFalse(boolean_value('False'))
def test_false_bool(self):
self.assertFalse(boolean_value(False))
