def find_user(self, query=None):
name = self.params('q')
if name:
page_limit, current_page, start, end = self._get_pagin_data()
if is_all_values_key(name):
result = find_entities(interfaces=[IPerson],
metadata_filter={'states': ['active']},
add_query=query)
else:
result = find_entities(interfaces=[IPerson],
text_filter={'text_to_search': name},
metadata_filter={'states': ['active']},
add_query=query)
resultlen = len(result)
if resultlen < start:
start = resultlen
result = list(itertools.islice(result, start, end))
default_img_url = self.request.static_url(
'novaideo:static/images/user100.png')
entries = [{
'id': str(get_oid(e)),
'text': e.title,
'img_url': e.get_picture_url('profil', default_img_url)
} for e in result]
result = {'items': entries, 'total_count': resultlen}
return result
return {'items': [], 'total_count': 0}
def evolve_person_tokens(root, registry):
from novaideo.views.filter import find_entities
from novaideo.content.interface import IPerson, Iidea, IProposal
from BTrees.OOBTree import OOBTree
request = get_current_request()
request.root = root # needed when executing the step via sd_evolve script
contents = find_entities(interfaces=[Iidea, IProposal])
for index, node in enumerate(contents):
if not hasattr(node, 'allocated_tokens'):
node.allocated_tokens = OOBTree()
node.len_allocated_tokens = PersistentDict({})
contents = find_entities(interfaces=[IPerson])
len_entities = str(len(contents))
for index, node in enumerate(contents):
if not hasattr(node, 'allocated_tokens'):
node.allocated_tokens = OOBTree()
node.len_allocated_tokens = PersistentDict({})
node.reserved_tokens = PersistentList([])
supports = [t for t in node.tokens_ref if t.__parent__ is not node]
for token in supports:
obj = token.__parent__
if obj.__parent__:
evaluation = 'oppose' if token in obj.tokens_opposition else 'support'
node.add_token(obj, evaluation, root)
obj.add_token(node, evaluation)
if token.proposal:
node.add_reserved_token(obj)
node.reindex()
log.info(str(index) + "/" + len_entities)
log.info('Persons evolved.')
def bind(self):
bindings = {}
user = get_current(self.request)
dace_catalog = find_catalog('dace')
novaideo_catalog = find_catalog('novaideo')
object_authors_index = novaideo_catalog['object_authors']
container_index = dace_catalog['container_oid']
query = container_index.eq(get_oid(self.context))
objects = find_entities(
interfaces=[IAmendment],
user=user,
add_query=query)
query = query & object_authors_index.any([get_oid(user)])
my_objs = find_entities(
interfaces=[IAmendment],
user=user,
add_query=query)
len_result = len(objects)
len_my = len(my_objs)
len_others = len_result - len_my
bindings['user'] = user
bindings['len_result'] = len_result
bindings['len_my'] = len_my
bindings['len_others'] = len_others
setattr(self, '_bindings', bindings)
def evolve_channels(root, registry):
from novaideo.views.filter import find_entities
from novaideo.content.interface import (
Iidea, IAmendment, IProposal, ICorrelation,
IPerson)
from novaideo.core import Channel
root = getSite()
general = root.channels[0] if root.channels else Channel(title=_("General"))
root.addtoproperty('channels', general)
root.setproperty('general_chanel', general)
contents = find_entities(
interfaces=[Iidea, IAmendment, IProposal, ICorrelation])
for entity in contents:
if not entity.channel:
entity.addtoproperty('channels', Channel())
channel = entity.channel
for comment in entity.comments:
channel.addtoproperty('comments', comment)
users = find_entities(
interfaces=[IPerson])
for member in users:
selections = getattr(member, 'selections', [])
for selection in selections:
channel = getattr(selection, 'channel', None)
if channel and member not in channel.members:
channel.addtoproperty('members', member)
log.info('Comments evolved.')
def find_user(self, query=None):
name = self.params('q')
if name:
page_limit, current_page, start, end = self._get_pagin_data()
if is_all_values_key(name):
result = find_entities(interfaces=[IPerson],
metadata_filter={'states': ['active']},
add_query=query)
else:
result = find_entities(interfaces=[IPerson],
text_filter={'text_to_search': name},
metadata_filter={'states': ['active']},
add_query=query)
resultlen = len(result)
if resultlen < start:
start = resultlen
result = list(itertools.islice(result, start, end))
default_img_url = self.request.static_url(
'novaideo:static/images/user100.png')
entries = [{'id': str(get_oid(e)),
'text': e.title,
'img_url': e.get_picture_url(
'profil', default_img_url)}
for e in result]
result = {'items': entries, 'total_count': resultlen}
return result
return {'items': [], 'total_count': 0}
def get_folder_content(folder, user,
add_query=None,
**args):
_filters = deepcopy(getattr(folder, 'filters', []))
objects = []
if _filters:
query = None
if add_query:
query = QUERY_OPERATORS['and'](query, add_query)
objects = find_entities(
user=user,
add_query=query,
filters=_filters,
filter_op='or',
**args)
oids = [get_oid(c) for c in folder.contents if can_access(user, c)]
if args:
contents = find_entities(
user=user,
intersect=oids,
**args)
oids = contents.ids if not isinstance(contents, list) else contents
if isinstance(objects, list):
objectmap = find_objectmap(folder)
objects = ResultSet(oids, len(oids), objectmap.object_for)
else: # ResultSet
objects.ids = list(objects.ids)
objects.ids.extend(oids)
objects.numids += len(oids)
return objects
def find_entity(self, interfaces=[], states=['published', 'active'], query=None):
name = self.params('q')
if name:
user = get_current()
page_limit, current_page, start, end = self._get_pagin_data()
if is_all_values_key(name):
result = find_entities(
interfaces=interfaces,
metadata_filter={
'states': states},
user=user,
add_query=query)
else:
result = find_entities(
interfaces=interfaces,
metadata_filter={
'states': states},
user=user,
text_filter={'text_to_search': name},
add_query=query)
resultlen = len(result)
if resultlen < start:
start = resultlen
result = list(itertools.islice(result, start, end))
entries = [{'id': str(get_oid(e)),
'text': e.title,
'icon': getattr(
e, 'icon', 'glyphicon glyphicon-question-sign')}
for e in result]
result = {'items': entries, 'total_count': resultlen}
return result
return {'items': [], 'total_count': 0}
def find_entities(self):
name = self.params('text_to_search')
contents = self.params('checkbox')
if contents and not isinstance(contents, (list, tuple)):
contents = [contents]
if not contents:
contents = get_default_searchable_content(self.request)
contents = [c[0] for c in contents]
if name:
states = ['published', 'active']
user = get_current()
root = getSite()
result = []
if is_all_values_key(name):
result = find_entities(metadata_filter={
'content_types': contents,
'states': states
},
user=user)
else:
result = find_entities(metadata_filter={
'content_types': contents,
'states': states
},
user=user,
text_filter={'text_to_search': name})
result_body = render_small_listing_objs(self.request,
list(result)[:NBRESULT],
user)
values = {
'entities':
result_body,
'all_url':
self.request.resource_url(root,
'@@search_result',
query={
'text_to_search': name,
'content_types': contents
}),
'advenced_search_url':
self.request.resource_url(root, '@@advanced_search')
}
body = self.content(args=values,
template=self.search_template)['body']
return {'body': body}
return {'body': ''}
def get_similar_questions(self):
user = get_current()
# text = self.params('text')
title = self.params('title')
keywords = self.params('keywords')
# text = text if text else ''
title = title if title else ''
keywords = keywords if keywords else []
if not isinstance(keywords, list):
keywords = [keywords]
if not keywords and not title: # and not text:
return {'body': ''}
title_keywords = extract_keywords(title)
# text_keywords = extract_keywords(text)
# keywords.extend(text_keywords[:5])
keywords.extend(title_keywords)
result = find_entities(
interfaces=[IQuestion],
user=user,
text_filter={'text_to_search': ', '.join(keywords)},
defined_search=True,
generate_text_search=True)
result_body = render_small_listing_objs(self.request,
list(result)[:30], user)
values = {'entities': result_body}
body = self.content(args=values,
template=self.search_question_template)['body']
return {'body': body}
def get_similar_ideas(self):
user = get_current()
# text = self.params('text')
title = self.params('title')
tree = self.params('tree')
# text = text if text else ''
title = title if title else ''
tree = tree if tree else {}
if not isinstance(tree, dict):
tree = json.loads(tree)
if not tree and not title: # and not text:
return {'body': ''}
title_keywords = extract_keywords(title)
# text_keywords = extract_keywords(text)
# keywords.extend(text_keywords[:5])
result = find_entities(
interfaces=[Iidea],
user=user,
metadata_filter={'tree': tree},
text_filter={'text_to_search': ', '.join(title_keywords)},
defined_search=True,
generate_text_search=True)
result_body = render_small_listing_objs(self.request,
list(result)[:30], user)
values = {'entities': result_body}
body = self.content(args=values,
template=self.search_idea_template)['body']
return {'body': body}
def update(self):
user = get_current()
filter_form, filter_data = self._add_filter(user)
args = merge_with_filter_view(self, {})
args['request'] = self.request
filters = [
{
'metadata_filter': {
'states': ['published'],
'interfaces': [IAnswer]
}
},
]
# Answer is non a searchable element
# we need add it to the args dict
args['interfaces'] = [IAnswer]
objects = find_entities(filters=filters,
user=user,
intersect=self._get_answers(user),
**args)
objects, sort_body = sort_view_objects(self, objects, ['answer'], user,
'nbsupport')
url = self.request.resource_url(self.context, self.name)
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results-answers"
len_answers = batch.seqlen
index = str(len_answers) if len_answers <= 1 else '*'
if not self.parent:
self.title = _(CONTENTS_MESSAGES[index],
mapping={'number': len_answers})
elif index != '*':
self.title = _('The answer')
filter_data['filter_message'] = self.title
filter_body = self.filter_instance.get_body(filter_data)
result_body, result = render_listing_objs(self.request, batch, user)
if filter_form:
result = merge_dicts(
{
'css_links': filter_form['css_links'],
'js_links': filter_form['js_links']
}, result)
values = {
'bodies': result_body,
'batch': batch,
'empty_message': self.empty_message,
'empty_icon': self.empty_icon,
'filter_body': filter_body,
'sort_body': sort_body,
'view': self
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
item['isactive'] = True
result['coordinates'] = {self.coordinates: [item]}
return result
def get_adapted_content(
email, request, interfaces=[Iidea], content_types=['idea'], last_sending_date=None):
body = ''
novaideo_catalog = find_catalog('novaideo')
identifier_index = novaideo_catalog['identifier']
query = identifier_index.any([email])
users = list(query.execute().all())
member = users[0] if users else None
query = None
if last_sending_date:
published_at_index = novaideo_catalog['published_at']
query = published_at_index.gt(last_sending_date)
entities = find_entities(
interfaces=interfaces,
metadata_filter={
'content_types': content_types,
'states': ['published'],
'keywords': getattr(member, 'keywords', [])},
sort_on='release_date',
add_query=query)
result = []
for obj in entities:
result.append(obj)
if len(result) == 5:
break
if result:
body = renderers.render(
CONTENT_TEMPLATE, {'entities': result}, request)
return body
def find_entities(self):
#page_limit, current_page, start, end = self._get_pagin_data()
user = get_current()
dace_catalog = find_catalog('dace')
system_catalog = find_catalog('system')
novaideo_catalog = find_catalog('novaideo')
filter_schema = FindEntitiesJson(self.context, self.request)
try:
appstruct = filter_schema.calculate_posted_filter()
except Exception as e:
return {'items': [], 'total_count': 0, 'error': True,
'message': '{}: {}'.format(
e.__class__.__name__, e.args[0])}
if appstruct is None:
return {'items': [], 'total_count': 0, 'error': True,
'message': 'appstruct is None'}
content_types_tree = appstruct['metadata_filter'].get('content_types', {}).copy()
content_types = list(content_types_tree.keys())
appstruct['metadata_filter'] = appstruct.get('metadata_filter', {})
appstruct['metadata_filter']['content_types'] = content_types
appstruct['dace'] = dace_catalog
appstruct['system'] = system_catalog
appstruct['novaideo'] = novaideo_catalog
entities = find_entities(
user=user, sort_on='release_date', include_site=True, **appstruct)
def dumps(obj):
"""return values of attributes descibed in
the colander schema node 'node' """
registry = get_current_registry()
content_type = registry.content.typeof(obj)
fields = content_types_tree.get(content_type, {})
result, to_add = get_obj_value(obj, fields)
if result is None:
return {}, to_add
return result, to_add
def merge_items(old_items, new_items):
for item in new_items:
oid = item.get('@id', None)
if oid and oid not in old_items:
old_items[oid] = item
elif oid:
old_item = old_items[oid]
old_items[oid] = merge_dicts([item, old_item])
items = {}
for entity in entities:
values, to_add = dumps(entity)
to_add.append(values)
merge_items(items, to_add)
result = {'items': list(items.values()), 'total_count': len(items)}
response = Response()
response.content_type = "application/json"
response.text = json.dumps(result, indent=2)
return response
def get_similar_questions(self):
user = get_current()
# text = self.params('text')
title = self.params('title')
keywords = self.params('keywords')
# text = text if text else ''
title = title if title else ''
keywords = keywords if keywords else []
if not isinstance(keywords, list):
keywords = [keywords]
if not keywords and not title:# and not text:
return {'body': ''}
title_keywords = extract_keywords(title)
# text_keywords = extract_keywords(text)
# keywords.extend(text_keywords[:5])
keywords.extend(title_keywords)
result = find_entities(
interfaces=[IQuestion],
user=user,
text_filter={'text_to_search': ', '.join(keywords)},
defined_search=True,
generate_text_search=True)
result_body = render_small_listing_objs(
self.request, list(result)[:30], user)
values = {'entities': result_body}
body = self.content(args=values,
template=self.search_question_template)['body']
return {'body': body}
def update(self):
user = get_current()
context_oid = get_oid(self.context)
dace_index = find_catalog('dace')
dace_container_oid = dace_index['container_oid']
query = dace_container_oid.eq(context_oid)
objects = find_entities(
user=user,
interfaces=[ISReport],
metadata_filter={
'states': [self.report_state]
},
add_query=query)
url = self.request.resource_url(
self.context, '',
query={'view_report_state': self.report_state})
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
self.title = _(self.title, mapping={'nb': batch.seqlen})
batch.target = "#results"+"-report-" + self.report_state.replace(' ', '')
result_body, result = render_listing_objs(
self.request, batch, user)
values = {'bodies': result_body,
'batch': batch,
'empty_message': self.empty_message,
'empty_icon': self.empty_icon}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def update(self):
self.execute(None)
user = get_current()
objects = find_entities(
user=user,
interfaces=[IPreregistration],
sort_on='release_date')
batch = Batch(
objects, self.request,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_registrations"
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = _(CONTENTS_MESSAGES[index],
mapping={'number': len_result})
result_body, result = render_listing_objs(
self.request, batch, user)
values = {
'bodies': result_body,
'length': len_result,
'batch': batch,
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def source(**args):
filters = [{'metadata_filter': {'content_types': ['person']}}]
objects = find_entities(user=user,
sort_on='last_connection',
filters=filters,
**args)
return objects
def update(self):
user = get_current()
context_oid = get_oid(self.context)
dace_index = find_catalog('dace')
dace_container_oid = dace_index['container_oid']
query = dace_container_oid.eq(context_oid)
objects = find_entities(
user=user,
interfaces=[ISReport],
metadata_filter={'states': [self.report_state]},
add_query=query)
url = self.request.resource_url(
self.context, '', query={'view_report_state': self.report_state})
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
self.title = _(self.title, mapping={'nb': batch.seqlen})
batch.target = "#results" + "-report-" + self.report_state.replace(
' ', '')
result_body, result = render_listing_objs(self.request, batch, user)
values = {
'bodies': result_body,
'batch': batch,
'empty_message': self.empty_message,
'empty_icon': self.empty_icon
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def start(self, context, request, appstruct, **kw):
user = get_current()
report = appstruct['_object_data']
context.addtoproperty('censoring_reason', report)
grant_roles(user=user, roles=(('Owner', report), ))
report.setproperty('author', user)
report.reindex()
context_oid = get_oid(context)
dace_index = find_catalog('dace')
dace_container_oid = dace_index['container_oid']
query = dace_container_oid.eq(context_oid)
reports = find_entities(
interfaces=[ISReport],
metadata_filter={
'states': ['pending']},
add_query=query)
for report in reports:
report.state = PersistentList(['processed'])
report.reindex()
context.init_len_current_reports()
adapter = get_current_registry().queryAdapter(
context, ISignalableObject)
if adapter is not None:
context.state.remove('reported')
adapter.censor(request)
return {}
def update(self):
self.execute(None)
user = get_current()
objects = find_entities(
user=user, interfaces=[IChallenge],
metadata_filter={'states': ['pending']},
sort_on='release_date')
url = self.request.resource_url(self.context, self.name)
batch = Batch(
objects, self.request, url=url, default_size=BATCH_HOME_DEFAULT_SIZE)
batch.target = "#results-home-challenges"
len_result = batch.seqlen
user = get_current()
if len_result == 0:
self.no_challenges = True
result = {}
result_body = []
else:
self.title = self.request.localizer.translate(self.title)
result_body, result = render_listing_objs(
self.request, batch, user, 'card')
values = {
'bodies': result_body,
'batch': batch
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def evolve_examined_tokens(root, registry):
from novaideo.views.filter import find_entities
from novaideo.content.interface import Iidea, IProposal
from BTrees.OOBTree import OOBTree
request = get_current_request()
request.root = root # needed when executing the step via sd_evolve script
contents = find_entities(
interfaces=[Iidea, IProposal],
metadata_filter={'states': ['examined']}
)
evaluations = {
1: 'support',
-1: 'withdraw',
0: 'oppose'
}
for index, node in enumerate(contents):
if hasattr(node, '_support_history'):
history = sorted(node._support_history, key=lambda e: e[1])
node.allocated_tokens = OOBTree()
node.len_allocated_tokens = PersistentDict({})
for value in history:
user, date, evaluation = value
user = get_obj(user)
evaluation = evaluations[evaluation]
if evaluation == 'withdraw':
node.remove_token(user)
else:
node.add_token(user, evaluation)
node.reindex()
log.info('Tokens evolved.')
def update(self):
self.execute(None)
user = get_current()
objects = find_entities(user=user,
interfaces=[IPreregistration],
sort_on='release_date')
batch = Batch(objects, self.request, default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_registrations"
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = _(CONTENTS_MESSAGES[index],
mapping={'number': len_result})
result_body, result = render_listing_objs(self.request, batch, user)
values = {
'bodies': result_body,
'length': len_result,
'batch': batch,
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def start(self, context, request, appstruct, **kw):
user = get_current()
report = appstruct['_object_data']
context.addtoproperty('censoring_reason', report)
grant_roles(user=user, roles=(('Owner', report), ))
report.setproperty('author', user)
report.reindex()
context_oid = get_oid(context)
dace_index = find_catalog('dace')
dace_container_oid = dace_index['container_oid']
query = dace_container_oid.eq(context_oid)
reports = find_entities(interfaces=[ISReport],
metadata_filter={'states': ['pending']},
add_query=query)
for report in reports:
report.state = PersistentList(['processed'])
report.reindex()
context.init_len_current_reports()
adapter = get_current_registry().queryAdapter(context,
ISignalableObject)
if adapter is not None:
context.state.remove('reported')
adapter.censor(request)
return {}
def evolve_alert_subjects(root, registry):
from novaideo.views.filter import find_entities
from novaideo.content.interface import IAlert
from novaideo.content.alert import InternalAlertKind
from BTrees.OOBTree import OOBTree
import transaction
contents = find_entities(interfaces=[IAlert])
len_entities = str(len(contents))
for index, alert in enumerate(contents):
if alert.kind == InternalAlertKind.comment_alert:
if alert.subjects:
subjects = alert.subjects
subject = subjects[0] if subjects else root
if hasattr(subject, 'channel'):
alert.delfromproperty('subjects', subject)
alert.addtoproperty('subjects', subject.channel)
alert.reindex()
else:
root.delfromproperty('alerts', alert)
if index % 1000 == 0:
log.info("**** Commit ****")
transaction.commit()
log.info(str(index) + "/" + len_entities)
log.info('Alerts evolved')
def update(self):
self.execute(None)
user = get_current()
folders = find_entities(
user=user,
interfaces=[ISmartFolder])
folders = [sf for sf in folders if not sf.parents]
folders = sorted(folders, key=lambda e: e.get_order())
root_navbars = generate_navbars(
self.request, self.context,
process_id='smartfoldermanagement',
descriminators=['body-action'])
len_result = len(folders)
index = str(len_result)
if len_result > 1:
index = '*'
self.title = _(CONTENTS_MESSAGES[index],
mapping={'number': len_result})
result_body, result = render_listing_objs(
self.request, folders, user)
values = {
'folders': result_body,
'body_actions': root_navbars['body_actions']
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def bind(self):
user = get_current()
folders = find_entities(user=user,
interfaces=[ISmartFolder
]) #states=['published'])
folders = [sf for sf in folders if not sf.parents]
folders = sorted(folders, key=lambda e: e.get_order())
return {'folders': folders}
def update(self):
user = get_current()
validated = getattr(self, 'validated', {})
not_validated = True if not validated else False
posted = self.request.POST or self.request.GET or {}
posted = posted.copy()
executed = not not_validated
if not_validated:
formviewinstance = SearchView(self.context, self.request)
formviewinstance.postedform = posted
validated = formviewinstance.calculate_posted_filter()
executed = getattr(formviewinstance, 'executed', False)
if not executed or self.params('filter_result'):
default_content = [key[0] for key in
get_default_searchable_content(self.request)]
default_content.remove("person")
default_content.remove("event")
if 'question' in default_content:
default_content.remove("question")
filter_ = {
'metadata_filter': {'content_types': default_content}
}
validated = merge_with_filter_view(self, {})
validated['request'] = self.request
validated['filters'] = [filter_]
objects = find_entities(
user=user,
**validated)
# content_types = validated.get('metadata_filter', {}).get('content_types', ['all'])
# objects, sort_body = sort_view_objects(
# self, objects, content_types, user)
url = self.request.resource_url(
self.context, self.request.view_name,
query=posted)
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results"
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = _(CONTENTS_MESSAGES[index],
mapping={'number': len_result})
result_body, result = render_listing_objs(
self.request, batch, user)
values = {'bodies': result_body,
'batch': batch}
# 'sort_body': sort_body}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def update(self):
body = ''
result = {}
if self.isactive or self.params('on_demand') == 'load':
user = get_current()
filter_form, filter_data = self._add_filter(user)
default_content = [self.content_type]
validated = self._get_validated({
'metadata_filter':
{'content_types': default_content,
'states': ['active', 'published']},
}, user)
args = {}
args = merge_with_filter_view(self, args)
args['request'] = self.request
objects = find_entities(
user=user,
filters=[validated],
**args)
objects, sort_body = sort_view_objects(
self, objects, [self.content_type], user)
url = self.request.resource_url(
self.context, '',
query={'view_content_id': self.content_id})
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
self.title = _(self.title, mapping={'nb': batch.seqlen})
batch.target = "#results-" + self.content_id
filter_instance = getattr(self, 'filter_instance', None)
filter_body = None
if filter_instance:
filter_data['filter_message'] = self.title
filter_body = filter_instance.get_body(filter_data)
result_body, result = render_listing_objs(
self.request, batch, user,
display_state=getattr(self, 'display_state', True))
values = {'bodies': result_body,
'batch': batch,
'empty_message': self.empty_message,
'empty_icon': self.empty_icon,
'filter_body': filter_body,
'filter_class': self.filter_class,
'sort_body': sort_body,
'view': self}
if filter_form:
result = merge_dicts(
{'css_links': filter_form['css_links'],
'js_links': filter_form['js_links']
}, result)
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
item['isactive'] = self.isactive
result['coordinates'] = {self.coordinates: [item]}
return result
def update(self):
body = ''
result = {}
if self.isactive or self.params('on_demand') == 'load':
user = get_current()
filter_form, filter_data = self._add_filter(user)
default_content = [self.content_type]
validated = self._get_validated({
'metadata_filter':
{'content_types': default_content,
'states': ['active', 'published']},
}, user)
args = {}
args = merge_with_filter_view(self, args)
args['request'] = self.request
objects = find_entities(
user=user,
filters=[validated],
**args)
objects, sort_body = sort_view_objects(
self, objects, [self.content_type], user)
url = self.request.resource_url(
self.context, '',
query={'view_content_id': self.content_id})
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
self.title = _(self.title, mapping={'nb': batch.seqlen})
batch.target = "#results-" + self.content_id
filter_instance = getattr(self, 'filter_instance', None)
filter_body = None
if filter_instance:
filter_data['filter_message'] = self.title
filter_body = filter_instance.get_body(filter_data)
result_body, result = render_listing_objs(
self.request, batch, user,
display_state=getattr(self, 'display_state', True))
values = {'bodies': result_body,
'batch': batch,
'empty_message': self.empty_message,
'empty_icon': self.empty_icon,
'filter_body': filter_body,
'filter_class': self.filter_class,
'sort_body': sort_body,
'view': self}
if filter_form:
result = merge_dicts(
{'css_links': filter_form['css_links'],
'js_links': filter_form['js_links']
}, result)
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
item['isactive'] = self.isactive
result['coordinates'] = {self.coordinates: [item]}
return result
def update(self):
self.execute(None)
user = get_current()
is_manager = has_role(user=user, role=('PortalManager', ))
filters = [
{'metadata_filter': {
'content_types': ['person']
}}
]
filter_form, filter_data = self._add_filter(user, is_manager)
args = merge_with_filter_view(self, {})
args['request'] = self.request
objects = find_entities(
user=user,
filters=filters,
**args)
objects, sort_body = sort_view_objects(
self, objects, ['person'], user)
url = self.request.resource_url(self.context, self.name)
batch = Batch(objects, self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_users"
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = self._get_title(
index=index, len_result=len_result, user=user)
filter_data['filter_message'] = self.title
filter_body = self.filter_instance.get_body(filter_data)
result_body, result = render_listing_objs(
self.request, batch, user)
novaideo_catalog = find_catalog('novaideo')
last_connection_index = novaideo_catalog['last_connection']
current_date = datetime.datetime.combine(
datetime.datetime.now(),
datetime.time(0, 0, 0, tzinfo=pytz.UTC))
inactive_users = find_users(
last_connection_index, current_date, (INACTIVITY_DURATION, None))
if filter_form:
result = merge_dicts(
{'css_links': filter_form['css_links'],
'js_links': filter_form['js_links']
}, result)
values = {'bodies': result_body,
'batch': batch,
'is_manager': is_manager,
'inactivity_duration': INACTIVITY_DURATION,
'inactive_users': inactive_users.__len__(),
'filter_body': filter_body,
'sort_body': sort_body}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def source(**args):
filters = [
{'metadata_filter': {
'content_types': ['challenge']
}}
]
objects = find_entities(
user=user, filters=filters, **args)
return objects
def update(self):
user = get_current()
validated = getattr(self, 'validated', {})
not_validated = True if not validated else False
posted = self.request.POST or self.request.GET or {}
posted = posted.copy()
executed = not not_validated
if not_validated:
formviewinstance = SearchView(self.context, self.request)
formviewinstance.postedform = posted
validated = formviewinstance.calculate_posted_filter()
executed = getattr(formviewinstance, 'executed', False)
if not executed or self.params('filter_result'):
default_content = [key[0] for key in
get_default_searchable_content(self.request)]
default_content.remove("person")
if 'question' in default_content:
default_content.remove("question")
filter_ = {
'metadata_filter': {'content_types': default_content}
}
validated = merge_with_filter_view(self, {})
validated['request'] = self.request
validated['filters'] = [filter_]
objects = find_entities(
user=user,
**validated)
# content_types = validated.get('metadata_filter', {}).get('content_types', ['all'])
# objects, sort_body = sort_view_objects(
# self, objects, content_types, user)
url = self.request.resource_url(
self.context, self.request.view_name,
query=posted)
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results"
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = _(CONTENTS_MESSAGES[index],
mapping={'number': len_result})
result_body, result = render_listing_objs(
self.request, batch, user)
values = {'bodies': result_body,
'batch': batch}
# 'sort_body': sort_body}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def source(**args):
filters = [{
'metadata_filter': {
'interfaces': [ISignalableEntity],
'states': ['reported'],
}
}]
objects = find_entities(user=user, filters=filters, **args)
return objects
def source(**args):
default_content = [self.content_type]
filter_ = self._get_validated({
'metadata_filter':
{'content_types': default_content,
'states': ['active', 'published']},
}, user)
objects = find_entities(user=user, filters=[filter_], **args)
return objects
def start(self, context, request, appstruct, **kw):
challenges = find_entities(interfaces=[IChallenge],
metadata_filter={'states': ['pending']})
for challenge in challenges:
if challenge.is_expired:
challenge.state = PersistentList(['closed', 'published'])
challenge.reindex()
return {}
def bind(self):
user = get_current()
folders = find_entities(
user=user,
interfaces=[ISmartFolder]
)#states=['published'])
folders = [sf for sf in folders if not sf.parents]
folders = sorted(folders, key=lambda e: e.get_order())
return {'folders': folders}
def source(**args):
default_content = [self.content_type]
filter_ = self._get_validated({
'metadata_filter':
{'content_types': default_content,
'states': ['active', 'published']},
}, user)
objects = find_entities(user=user, filters=[filter_], **args)
return objects
def find_entities(self):
name = self.params('text_to_search')
contents = self.params('checkbox')
if contents and not isinstance(contents, (list, tuple)):
contents = [contents]
if not contents:
contents = get_default_searchable_content(
self.request)
contents = [c[0] for c in contents]
if name:
states = ['published', 'active']
user = get_current()
root = getSite()
result = []
if is_all_values_key(name):
result = find_entities(
metadata_filter={
'content_types': contents,
'states': states},
user=user)
else:
result = find_entities(
metadata_filter={
'content_types': contents,
'states': states},
user=user,
text_filter={'text_to_search': name})
result_body = render_small_listing_objs(
self.request, list(result)[:NBRESULT], user)
values = {'entities': result_body,
'all_url': self.request.resource_url(
root, '@@search_result',
query={'text_to_search': name,
'content_types': contents}),
'advenced_search_url': self.request.resource_url(
root, '@@advanced_search')}
body = self.content(args=values,
template=self.search_template)['body']
return {'body': body}
return {'body': ''}
def source(**args):
filters = [
{'metadata_filter': {
'interfaces': [ISignalableEntity],
'states': ['reported'],
}}
]
objects = find_entities(
user=user,filters=filters, **args)
return objects
def source(**args):
filters = [
{'metadata_filter': {
'content_types': ['proposal'],
'states': ['submitted_support']
}}
]
objects = find_entities(
user=user, include_site=True, filters=filters, **args)
return objects
def source(**args):
filters = [
{'metadata_filter': {
'content_types': ['proposal'],
'states': ['submitted_support']
}}
]
objects = find_entities(
user=user, include_site=True, filters=filters, **args)
return objects
def publish_organizations(root, registry):
from novaideo.views.filter import find_entities
from novaideo.content.interface import IOrganization
contents = find_entities(interfaces=[IOrganization])
for org in contents:
org.state = PersistentList(['published'])
org.reindex()
log.info('Orgnaizations evolved.')
def update(self):
self.execute(None)
user = get_current()
filter_form, filter_data = self._add_filter(user)
args = merge_with_filter_view(self, {})
args['request'] = self.request
objects = find_entities(user=user,
intersect=self._get_content_ids(user),
include_archived=self.include_archived,
**args)
objects, sort_body = sort_view_objects(self,
objects,
self.content_types,
user,
intersect=getattr(
self, 'sorts', None))
url = self.request.resource_url(self.context, self.name)
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_contents"
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = self._get_title(index=index,
len_result=len_result,
user=user)
filter_data['filter_message'] = self.title
filter_body = self.filter_instance.get_body(filter_data)
result_body, result = render_listing_objs(self.request,
batch,
user,
display_state=getattr(
self, 'display_state',
True))
if filter_form:
result = merge_dicts(
{
'css_links': filter_form['css_links'],
'js_links': filter_form['js_links']
}, result)
values = {
'bodies': result_body,
'batch': batch,
'filter_body': filter_body,
'sort_body': sort_body
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def evolve_person_tokens(root, registry):
from novaideo.views.filter import find_entities
from novaideo.content.interface import IPerson, Iidea, IProposal
from BTrees.OOBTree import OOBTree
request = get_current_request()
request.root = root # needed when executing the step via sd_evolve script
contents = find_entities(
interfaces=[Iidea, IProposal]
)
for index, node in enumerate(contents):
if not hasattr(node, 'allocated_tokens'):
node.allocated_tokens = OOBTree()
node.len_allocated_tokens = PersistentDict({})
contents = find_entities(
interfaces=[IPerson]
)
len_entities = str(len(contents))
for index, node in enumerate(contents):
if not hasattr(node, 'allocated_tokens'):
node.allocated_tokens = OOBTree()
node.len_allocated_tokens = PersistentDict({})
node.reserved_tokens = PersistentList([])
supports = [t for t in node.tokens_ref
if t.__parent__ is not node]
for token in supports:
obj = token.__parent__
if obj.__parent__:
evaluation = 'oppose' if token in obj.tokens_opposition else 'support'
node.add_token(obj, evaluation, root)
obj.add_token(node, evaluation)
if token.proposal:
node.add_reserved_token(obj)
node.reindex()
log.info(str(index) + "/" + len_entities)
log.info('Persons evolved.')
def find_users(last_connection_index, current_date, alert):
alert_date_min = current_date - datetime.timedelta(days=alert[0])
query = last_connection_index.le(alert_date_min)
if alert[1]:
alert_date_max = current_date - datetime.timedelta(days=alert[1] - 1)
query = query & last_connection_index.ge(alert_date_max)
users = find_entities(interfaces=[IPerson],
metadata_filter={'states': ['active']},
add_query=query)
return users
def update(self):
current_date = datetime.datetime.combine(
datetime.datetime.now(), datetime.time(0, 0, 0, tzinfo=pytz.UTC))
alert_date_min = current_date - datetime.timedelta(
days=INACTIVITY_DURATION)
user = get_current()
filters = [{
'metadata_filter': {
'content_types': ['person'],
'states': ['active']
},
'temporal_filter': {
'negation': True,
'connected_date': {
'connected_before': None,
'connected_after': alert_date_min
}
}
}]
filter_form, filter_data = self._add_filter(user, alert_date_min)
args = merge_with_filter_view(self, {})
args['request'] = self.request
objects = find_entities(user=user,
sort_on='last_connection',
filters=filters,
**args)
url = self.request.resource_url(self.context, self.name)
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_users"
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = self._get_title(index=index,
len_result=len_result,
user=user)
filter_data['filter_message'] = self.title
filter_body = self.filter_instance.get_body(filter_data)
result_body, result = render_listing_objs(self.request, batch, user)
values = {
'bodies': result_body,
'batch': batch,
'filter_body': filter_body
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
result['css_links'] = filter_form['css_links']
result['js_links'] = filter_form['js_links']
return result
def evolve_state_files(root, registry):
from novaideo.views.filter import find_entities
from novaideo.content.interface import IFile
contents = find_entities(interfaces=[IFile])
for file_ in contents:
if not file_.state:
file_.state = PersistentList(['draft'])
file_.reindex()
log.info('Working groups evolved.')
def update(self):
body = ''
result = {}
if self.isactive or self.params('on_demand') == 'load':
current_user = get_current()
validated = {
'metadata_filter': {
'content_types': [self.content_type],
'states': ['active', 'published']
}
}
novaideo_catalog = find_catalog('novaideo')
organizations_index = novaideo_catalog['organizations']
query = organizations_index.any([self.context.__oid__])
objects = find_entities(user=current_user,
filters=[validated],
add_query=query)
sort_url = self.request.resource_url(
self.context,
'@@index',
query={'view_content_attr': self.content_id})
objects, sort_body = sort_view_objects(self,
objects,
[self.content_type],
current_user,
sort_url=sort_url)
url = self.request.resource_url(
self.context,
'@@index',
query={'view_content_attr': self.content_id})
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results-" + self.content_type
self.title = _(self.title, mapping={'nb': batch.seqlen})
result_body, result = render_listing_objs(
self.request,
batch,
current_user,
display_state=getattr(self, 'display_state', True))
values = {
'bodies': result_body,
'batch': batch,
'empty_message': self.empty_message,
'empty_icon': self.empty_icon,
'sort_body': sort_body
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
item['isactive'] = getattr(self, 'isactive', False)
result['coordinates'] = {self.coordinates: [item]}
return result
def source(**args):
filters = [
{'metadata_filter': {
'content_types': ['person']
}}
]
objects = find_entities(
user=user,
sort_on='last_connection',
filters=filters, **args)
return objects
def update(self):
self.execute(None)
user = get_current()
filter_form, filter_data = self._add_filter(user)
filters = [{
'metadata_filter': {
'negation': True,
'states': ['examined']
}
}, {
'metadata_filter': {
'content_types': ['idea'],
'states': ['published']
}
}]
args = {}
args = merge_with_filter_view(self, args)
args['request'] = self.request
objects = find_entities(user=user, filters=filters, **args)
objects, sort_body = sort_view_objects(self, objects, ['idea'], user,
'nbsupport')
url = self.request.resource_url(self.context, 'seeideastoexamine')
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_contents"
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = _(CONTENTS_MESSAGES[index],
mapping={'number': len_result})
filter_data['filter_message'] = self.title
filter_body = self.filter_instance.get_body(filter_data)
result_body, result = render_listing_objs(self.request, batch, user)
if filter_form:
result = merge_dicts(
{
'css_links': filter_form['css_links'],
'js_links': filter_form['js_links']
}, result)
values = {
'bodies': result_body,
'batch': batch,
'filter_body': filter_body,
'sort_body': sort_body
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def start(self, context, request, appstruct, **kw):
challenges = find_entities(
interfaces=[IChallenge],
metadata_filter={
'states': ['pending']})
for challenge in challenges:
if challenge.is_expired:
challenge.state = PersistentList(['closed', 'published'])
challenge.reindex()
return {}
def update(self):
self.execute(None)
user = get_current()
filter_form, filter_data = self._add_filter(user)
filters = [
{'metadata_filter': {
'negation': True,
'states': ['examined']
}},
{'metadata_filter': {
'content_types': ['idea'],
'states': ['published']
}}
]
args = {}
args = merge_with_filter_view(self, args)
args['request'] = self.request
objects = find_entities(user=user,
filters=filters,
**args)
objects, sort_body = sort_view_objects(
self, objects, ['idea'], user, 'nbsupport')
url = self.request.resource_url(self.context, 'seeideastoexamine')
batch = Batch(objects, self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_contents"
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = _(CONTENTS_MESSAGES[index],
mapping={'number': len_result})
filter_data['filter_message'] = self.title
filter_body = self.filter_instance.get_body(filter_data)
result_body, result = render_listing_objs(
self.request, batch, user)
if filter_form:
result = merge_dicts(
{'css_links': filter_form['css_links'],
'js_links': filter_form['js_links']
}, result)
values = {'bodies': result_body,
'batch': batch,
'filter_body': filter_body,
'sort_body': sort_body
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
