def update(self): self.execute(None) vote_actions = get_vote_actions_body(self.context, self.request) try: navbars = generate_navbars(self.request, self.context, text_action=vote_actions['activators']) except ObjectRemovedException: return HTTPFound(self.request.resource_url(getSite(), '')) resources = merge_dicts(navbars['resources'], vote_actions['resources'], ('js_links', 'css_links')) resources['js_links'] = list(set(resources['js_links'])) resources['css_links'] = list(set(resources['css_links'])) messages = vote_actions['messages'] if not messages: messages = navbars['messages'] values = { 'registration': self.context, 'footer_body': navbars['footer_body'], 'navbar_body': navbars['navbar_body'], 'vote_actions_body': vote_actions['body'] } result = {} body = self.content(args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) item['messages'] = messages item['isactive'] = vote_actions['isactive'] or navbars['isactive'] result.update(resources) result['coordinates'] = {self.coordinates: [item]} result = merge_dicts(self.requirements_copy, result) return result
def update(self,): if not self.validated_children: e = ViewError() e.principalmessage = CallViewErrorPrincipalmessage causes = set() for view, er in self.errors: causes.update(er.causes) e.causes = list(causes) raise e result = {} global_result = {} for view in self.validated_children: try: view_result = view.update() except ViewError as e: continue if self.isexecutable and \ view.isexecutable and \ view.finished_successfully: self.finished_successfully = True return self.success(view_result) currentview = view if 'view' in view_result: currentview = view_result['view'] global_result = merge_dicts(view_result, global_result) if len(view_result['coordinates']) == 1 and \ len(view_result['coordinates'].items()[0][1]) == 1: coordinate = view_result['coordinates'].items()[0][0] item = view_result['coordinates'].items()[0][1][0] if coordinate in result: result[coordinate].append(item) else: result[coordinate] = [item] else: for coordinate, values in view_result['coordinates'].items(): item = values[0] subviewid = currentview.viewid+'_'+coordinate item['id'] = subviewid if coordinate in result: result[coordinate].append(item) else: result[coordinate] = [item] for coordinate, items in result.items(): values = {'items': items, 'id':self.viewid+coordinate } body = self.content(args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) global_result['coordinates'][coordinate] = [item] #if not (len(self.validated_children) == len(self.contexts)): # global_result['messages'] global_result = merge_dicts(self.requirements_copy, global_result) return global_result
def update(self): self.execute(None) user = get_current() filter_form, filter_data = self._add_filter(user) filters = [{ 'metadata_filter': { 'interfaces': [ISignalableEntity], 'states': ['reported'], } }] args = {} args = merge_with_filter_view(self, args) args['request'] = self.request objects = find_entities(interfaces=[ISignalableEntity], user=user, filters=filters, **args) objects, sort_body = sort_view_objects(self, objects, ['proposal'], user) url = self.request.resource_url(self.context, 'seereportedcontents') 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]} result = merge_dicts(self.requirements_copy, result) return result
def update(self): self.execute(None) user = get_current() filter_form, filter_data = self._add_filter(user) filters = [ {'metadata_filter': { 'interfaces': [ISignalableEntity], 'states': ['reported'], }} ] args = {} args = merge_with_filter_view(self, args) args['request'] = self.request objects = find_entities( interfaces=[ISignalableEntity], user=user, filters=filters, **args) objects, sort_body = sort_view_objects( self, objects, ['proposal'], user) url = self.request.resource_url( self.context, 'seereportedcontents') 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]} result = merge_dicts(self.requirements_copy, result) return result
def update(self): self.execute(None) try: navbars = generate_navbars(self.request, self.context) except ObjectRemovedException: return HTTPFound(self.request.resource_url(getSite(), '')) organization = self.context current_user = get_current() evaluation_chart = render_object_evaluation_stat(self.context, self.request) examination_chart = render_object_examination_stat(self.context, self.request) values = { 'organization': organization, 'state': get_states_mapping( current_user, organization, getattr(organization, 'state_or_none', [None])[0]), 'navbar_body': navbars['navbar_body'], 'actions_bodies': navbars['body_actions'], 'footer_body': navbars['footer_body'], 'is_portal_manager': has_role(role=('PortalManager',)), 'evaluation_chart': evaluation_chart, 'examination_chart': examination_chart, } result = {} result = merge_dicts(navbars['resources'], result, ('css_links', 'js_links')) body = self.content(args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) item['messages'] = navbars['messages'] item['isactive'] = navbars['isactive'] result['coordinates'] = {self.coordinates: [item]} return result
def update(self): self.execute(None) involveds = self.context.execution_context.all_active_involveds().values() involveds = [e['entities'] for e in involveds] involveds = [entity for entities in involveds for entity in entities] dace_ui_api = get_current_registry().getUtility(IDaceUIAPI, 'dace_ui_api') all_actions = dace_ui_api.get_actions( involveds, self.request, self.context) action_updated, messages, \ resources, actions = dace_ui_api.update_actions( self.request, all_actions, False, False) result = {} values = {'actions': actions, 'process':self.context, 'tabid':self.__class__.__name__+'AllActions'} body = self.content(args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) item['messages'] = messages item['isactive'] = action_updated result['coordinates'] = {self.coordinates:[item]} result.update(resources) result = merge_dicts(self.requirements_copy, result) return result
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 update(self,): #validation if not self.validated_children and \ not self.include_failed_views: error = ViewError() error.principalmessage = MutltipleViewErrorPrincipalmessage causes = set() for viewinstance, er in self.errors: causes.update(er.causes) error.causes = list(causes) raise error #update children result = {} if self.include_failed_views: result = self._update_all_children() else: result = self._update_validated_children() if not result: error = ViewError() error.principalmessage = MutltipleViewErrorPrincipalmessage error.causes = MutltipleViewErrorCauses raise error if not isinstance(result, dict): return result for _coordinate in result['coordinates']: coordinate = _coordinate if self.merged: coordinate = self.coordinates items = result['coordinates'][coordinate] isactive = False for item in items: if item['isactive']: isactive = True break if not isactive: self._activate(items) if self.parent is None: isactive = True _item = {'isactive':isactive, 'items': items, 'view': self, 'id':self.viewid} values = {'coordinates': coordinate, 'subitem': _item, 'parent': self} body = self.content(args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) item['isactive'] = isactive result['coordinates'][coordinate] = [item] result = merge_dicts(self.requirements_copy, result) return result
def update(self): comment_id = self.params('comment_id') user = get_current() comment = None try: obj = get_obj(int(comment_id)) if comment_id else None if isinstance(obj, Comment) and can_access(user, obj): comment = obj except Exception as error: log.warning(error) comment_body = '' if comment: comment_body = render_listing_obj( self.request, comment, user) values = { 'comment_body': comment_body } result = {} body = self.content( args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) result['coordinates'] = {self.coordinates: [item]} result = merge_dicts(self.requirements_copy, result) return result
def _update_all_children(self): result = {} for view in self.all_children: try: if view in self.failed_children: error = dict(self.errors)[view] view_result = view.failure(error) else: view_result = view.update() except ViewError as e: continue if self.isexecutable and view.isexecutable and \ view.finished_successfully: self.finished_successfully = True #for wizards view.init_stepid() return self.success(view_result) if not isinstance(view_result, dict): return view_result result = merge_dicts(view_result, result) return result
def get_view_requirements(self): result = self.requirements_copy for view in self.validated_children: view_requirements = view.get_view_requirements() result = merge_dicts(view_requirements, result) return result
def update(self): result = {} context = self.get_binding('context') if context.is_finished: ballot_type = context.report.ballottype values = { 'ballot': context, 'ballot_type': ballot_type, 'tab_id': self.viewid + self.coordinates } ballot_type_body = self.content( args=values, template=ballot_type.templates.get('result'))['body'] values = {'body': ballot_type_body, 'ballot': context} body = self.content(args={ 'body': ballot_type_body, 'ballot': context }, template=self.template)['body'] else: values = {'body': '', 'ballot': context} body = self.content(args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) result['coordinates'] = {self.coordinates: [item]} result = merge_dicts(self.requirements_copy, result) return result
def update_actions( self, request, all_actions, ignor_form=False, ignor_actionsofactions=True, include_resources=True): messages = {} #find all business actions form_id = None #get submited form view if not ignor_form and '__formid__' in request.POST: #if request.POST['__formid__'].find(object_oid) >= 0: form_id = request.POST['__formid__'] toreplay, valid_form_id, action_updated, \ resources, allbodies_actions = self._ajax_views( request, all_actions, form_id, ignor_actionsofactions, include_resources) if toreplay: request.POST.clear() old_resources = resources old_allbodies_actions = allbodies_actions actions_toreplay = [] for context, action in list(all_actions): try: action.validate(context, request) if context.__parent__: actions_toreplay.append((context, action)) except Exception as e: pass action_updated, messages, \ resources, allbodies_actions = self.update_actions( request, actions_toreplay, ignor_form, include_resources=include_resources) if old_resources is not None: resources = merge_dicts(old_resources, resources, ('js_links', 'css_links')) resources['js_links'] = list(set(resources['js_links'])) resources['css_links'] = list(set(resources['css_links'])) if old_allbodies_actions is not None: allbodies_actions.extend(old_allbodies_actions) return True, messages, resources, allbodies_actions if form_id and \ not action_updated and valid_form_id and all_actions: error = ViewError() error.principalmessage = u"Action non realisee" error.causes = ["Vous n'avez plus le droit de realiser cette action.", "L'action est verrouillee par un autre utilisateur."] message = error.render_message(request) messages.update({error.type: [message]}) return action_updated, messages, resources, allbodies_actions
def update(self): user = get_current() correlations = [c for c in self.context.source_correlations \ if c.type == 0 and can_access(user, c)] target_correlations = [c for c in self.context.target_correlations \ if c.type == 0 and can_access(user, c)] relatedcontents = [] all_messages = {} isactive = False all_resources = {} all_resources['js_links'] = [] all_resources['css_links'] = [] for correlation in correlations: contents = correlation.targets for content in contents: correlation_data, resources, \ messages, action_updated = self._correlation_action(correlation) correlation_data.update({'content': content, 'url': content.url(self.request), 'correlation': correlation}) relatedcontents.append(correlation_data) isactive = action_updated or isactive self._update_data(messages, resources, all_messages, all_resources) for correlation in target_correlations: content = correlation.source correlation_data, resources, \ messages, action_updated = self._correlation_action(correlation) correlation_data.update({'content': content, 'url': content.url(self.request), 'correlation': correlation}) relatedcontents.append(correlation_data) isactive = action_updated or isactive self._update_data(messages, resources, all_messages, all_resources) len_contents = len(relatedcontents) index = str(len_contents) if len_contents > 1: index = '*' message = (_(ASSOCIATION_MESSAGES[index]), len_contents, index) self.message = message result = {} values = { 'relatedcontents': relatedcontents, 'current_user': user, 'message': message } body = self.content(result=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) result['coordinates'] = {self.coordinates:[item]} item['messages'] = all_messages item['isactive'] = isactive result.update(all_resources) result = merge_dicts(self.requirements_copy, result) 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 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() 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 update(self): result = {} values = { 'object': self.context, 'tab_id': self.viewid + self.coordinates } body = self.content(args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) result['coordinates'] = {self.coordinates: [item]} result = merge_dicts(self.requirements_copy, result) return result
def get_view_requirements(self): stepidkey = STEPID + self.viewid if stepidkey in self.request.session: self.currentsteps = [self.nodes[self.request.session.pop(stepidkey)]] result = self.requirements_copy for view in self.currentsteps: view_requirements = view.get_view_requirements() result = merge_dicts(view_requirements, result) return result
def update(self): result = {} body, resources, messages, isactive = self._rendre_comments( self.context.comments, True) item = self.adapt_item(body, self.viewid) item['messages'] = messages item['isactive'] = isactive result['coordinates'] = {self.coordinates:[item]} result.update(resources) result = merge_dicts(self.requirements_copy, result) return result
def update(self): self.execute(None) result = {} allprocessesdef = [{'title':k, 'processes':v} \ for k, v in self._processes().items()] values = {'allprocessesdef': allprocessesdef} body = self.content(args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) result['coordinates'] = {self.coordinates:[item]} result = merge_dicts(self.requirements_copy, result) return result
def update(self): self.execute(None) user = get_current() text_analyzer = get_current_registry().getUtility( ITextAnalyzer, 'text_analyzer') def actions_getter(): return [a for a in self.context.actions \ if getattr(a.action, 'style', '') == 'button'] actions_navbar = get_actions_navbar(actions_getter, self.request, ['global-action', 'text-action']) global_actions = actions_navbar['global-action'] isactive = actions_navbar['modal-action']['isactive'] messages = actions_navbar['modal-action']['messages'] resources = actions_navbar['modal-action']['resources'] result = {} textdiff = '' descriptiondiff = '' keywordsdiff = [] proposal = self.context.proposal textdiff = self.context.text_diff soup, descriptiondiff = text_analyzer.render_html_diff( '<div>'+getattr(proposal, 'description', '')+'</div>', '<div>'+getattr(self.context, 'description', '')+'</div>') for k in proposal.keywords: if k in self.context.keywords: keywordsdiff.append({'title': k, 'state': 'nothing'}) else: keywordsdiff.append({'title': k, 'state': 'del'}) [keywordsdiff.append({'title': k, 'state': 'ins'}) \ for k in self.context.keywords if k not in proposal.keywords] values = { 'amendment': self.context, 'state': get_states_mapping( user, self.context, self.context.state[0]), 'textdiff': textdiff, 'descriptiondiff':descriptiondiff, 'keywordsdiff':keywordsdiff, 'current_user': user, 'navbar_body': navbar_body_getter(self, actions_navbar), 'end_explanation':self._end_explanation(global_actions) } self._add_requirements(user) body = self.content(result=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) item['messages'] = messages item['isactive'] = isactive result.update(resources) result['coordinates'] = {self.coordinates:[item]} result = merge_dicts(self.requirements_copy, result) 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 update(self): self.execute(None) try: navbars = generate_navbars(self.request, self.context) except ObjectRemovedException: return HTTPFound(self.request.resource_url(getSite(), '')) user = self.context current_user = get_current() details = {} stats = get_object_stat(self.context, self.request) stats['nb_other'] = stats.get('nb_other', 0) + len( user.evaluated_objs_ids()) stas_len = sum(stats.values()) evaluation_chart = render_object_evaluation_stat( self.context, self.request) examination_chart = render_object_examination_stat( self.context, self.request) values = { 'user': user, 'proposals': None, 'state': get_states_mapping(current_user, user, getattr(user, 'state_or_none', [None])[0]), 'navbar_body': navbars['navbar_body'], 'actions_bodies': navbars['body_actions'], 'footer_body': navbars['footer_body'], 'is_portal_manager': has_role(role=('PortalManager', )), 'contributions_len': stas_len, 'details': stats, 'evaluation_chart': evaluation_chart, 'examination_chart': examination_chart, } result = {} result = merge_dicts(navbars['resources'], result, ('css_links', 'js_links')) body = self.content(args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) item['messages'] = navbars['messages'] item['isactive'] = navbars['isactive'] result['coordinates'] = {self.coordinates: [item]} return result
def get_view_requirements(self): bindings = self.bind() bindings.update({ 'request': self.request, 'context': self.context, }) schema = self.schema.bind(**bindings) reqts = self.form_class(schema).get_widget_resources() result = {} result['js_links'] = list(reqts['js']) result['css_links'] = list(reqts['css']) result = merge_dicts(self.requirements_copy, result) return result
def update(self): self.execute(None) result = {} all_involveds = self._datas( self.context.execution_context.all_classified_involveds()) involveds = [a for a in all_involveds if a['iscurrent']] values = {'datas': involveds, 'alldatas':all_involveds, 'tabid':self.__class__.__name__+'AllDatas'} body = self.content(args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) result['coordinates'] = {self.coordinates:[item]} result = merge_dicts(self.requirements_copy, result) return result
def update(self): self.execute(None) result = {} dace_ui_api = get_current_registry().getUtility(IDaceUIAPI, 'dace_ui_api') values = dace_ui_api.statistic_processes(self, self.context.processes, self.__class__.__name__) dates = dace_ui_api.statistic_dates(self, self.context.processes) values['dates'] = dates body = self.content(args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) result['coordinates'] = {self.coordinates:[item]} result = merge_dicts(self.requirements_copy, result) return result
def update(self): self.execute(None) user = get_current() filter_form, filter_data = self._add_filter(user) filters = [ {'metadata_filter': { 'content_types': ['challenge'] }} ] 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, ['challenge'], 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-home-challenges" len_result = batch.seqlen index = str(len_result) if len_result > 1: index = '*' self.title = self.request.localizer.translate( _(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, 'card') 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 update(self): stepidkey = STEPID+self.viewid #TODO #if stepidkey in self.request.POST: # self.currentsteps = [self.viewsinstances[self.request.POST[stepidkey]]] if stepidkey in self.request.session: self.currentsteps = [self.viewsinstances[self.request.session.pop(stepidkey)]] result = None finished_successfully = False viewinstance, finished_successfully, result = self._get_result( self.currentsteps) self.isexecutable = viewinstance.isexecutable if viewinstance is not None and \ finished_successfully and viewinstance._outgoing and \ not(viewinstance._outgoing[0].target == self.endnode): result = None while(result is None and \ not(viewinstance._outgoing[0].target == self.endnode)): viewinstance.after_update() nextsteps = [transition.target for transition in viewinstance._outgoing \ if (transition.validate() and not transition.isdefault)] if not nextsteps: nextsteps = [transition.target for transition in viewinstance._outgoing \ if transition.isdefault] viewinstance, finished_successfully, result = self._get_result( nextsteps) self.isexecutable = viewinstance.isexecutable if isinstance(result, dict) and self.include_informations: wizardinfo = self.getwizardinformationsview() result = merge_dicts(result, wizardinfo, ('js_links', 'css_links')) for coordinates in result['coordinates']: item = result['coordinates'][coordinates][0] body = item['body'] body = wizardinfo['body']+body item['body'] = body if finished_successfully and \ (viewinstance._outgoing[0].target == self.endnode): self.finished_successfully = True viewinstance.after_update() self.request.session.__delitem__(stepidkey) if viewinstance.isexecutable: return self.success() return result
def update(self): self.execute(None) result = {} tabid = self.__class__.__name__+'AllProcesses' page, pages, allprocesses = self._processes(tabid) values = {'processes': allprocesses, 'p_id': self.context.title, 'tabid':tabid, 'page': page, 'pages': pages, 'url': self.request.resource_url(self.context, '@@ProcessInst')} body = self.content(args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) result['coordinates'] = {self.coordinates:[item]} result = merge_dicts(self.requirements_copy, result) return result
def update_processes(self, view, processes, tabid): result = {} processes = sorted(processes, key=lambda p: p.created_at) page, pages, processes = calculatePage(processes, view, tabid) nb_encours, nb_bloque, nb_termine, allprocesses = self._processes(view, processes) values = {'processes': allprocesses, 'encours': nb_encours, 'bloque': nb_bloque, 'termine': nb_termine, 'tabid': tabid, 'page': page, 'pages': pages, 'url': view.request.resource_url(view.context, '@@'+view.name)} body = view.content(args=values, template='daceui:templates/runtime_view.pt')['body'] item = view.adapt_item(body, view.viewid) result['coordinates'] = {view.coordinates:[item]} result = merge_dicts(view.requirements, result) return result
def update(self): user = get_current() correlations = [(content, c) for content, c in self.context.all_related_contents if c.type == 0 and can_access(user, content)] relatedcontents = [] all_messages = {} isactive = False all_resources = {} all_resources['js_links'] = [] all_resources['css_links'] = [] for content, correlation in correlations: correlation_data, resources, \ messages, action_updated = self._correlation_action(correlation) correlation_data.update({'content': content, 'url': content.url, 'correlation': correlation}) relatedcontents.append(correlation_data) isactive = action_updated or isactive self._update_data(messages, resources, all_messages, all_resources) len_contents = len(relatedcontents) index = str(len_contents) if len_contents > 1: index = '*' message = (_(ASSOCIATION_MESSAGES[index]), len_contents, index) self.message = message result = {} values = { 'relatedcontents': relatedcontents, 'current_user': user, 'message': message } body = self.content(args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) result['coordinates'] = {self.coordinates: [item]} item['messages'] = all_messages item['isactive'] = isactive result.update(all_resources) result = merge_dicts(self.requirements_copy, result) return result
def update(self): user = get_current() formviewinstance = SearchView(self.context, self.request) formviewinstance.postedform = self.request.POST appstruct = formviewinstance.get_appstruct() content_types = appstruct['content_types'] text = appstruct['text_to_search'] objects = search(text, content_types, user) url = self.request.resource_url(self.context, '', query={'content_types':content_types, 'text_to_search':appstruct['text_to_search']}) 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={'nember': len_result}) result_body = [] for obj in batch: object_values = {'object':obj, 'current_user': user, 'state': get_states_mapping(user, obj, getattr(obj, 'state', [None])[0])} body = self.content(result=object_values, template=obj.result_template)['body'] result_body.append(body) result = {} values = { 'bodies': result_body, 'length': len_result, 'batch': batch } body = self.content(result=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) result['coordinates'] = {self.coordinates:[item]} result = merge_dicts(self.requirements_copy, result) return result
def _rendre_comments(self, comments, current_user, origin=False, batch=None, unread_comments=[], filtered=False): all_comments = [] resources = {'css_links': [], 'js_links': []} for obj in comments: try: navbars = generate_listing_menu( self.request, obj, template='novaideo:views/templates/comment_menu.pt') except ObjectRemovedException: continue resources = merge_dicts(navbars['resources'], resources) object_values = { 'context': obj, 'menu_body': navbars['menu_body'], 'primary_menu_body': navbars['primary_menu_body'], 'footer_actions_body': navbars['footer_actions_body'], 'footer_body': navbars['footer_body'] } all_comments.append(object_values) all_comments = sorted(all_comments, key=lambda e: e['context'].created_at) values = { 'comments': all_comments, 'unread_comments': unread_comments, 'filtered': filtered, 'current_user': current_user, 'view': self, 'origin': origin, 'batch': batch, 'level': COMMENT_LEVEL } body = self.content(args=values, template=self.template)['body'] return body, resources
def update(self): vote_actions = self.get_binding('vote_actions') navbars = self.get_binding('navbars') root = self.get_binding('root') if navbars is None: return HTTPFound(self.request.resource_url(root, '')) resources = merge_dicts(navbars['resources'], vote_actions['resources'], ('js_links', 'css_links')) resources['js_links'] = list(set(resources['js_links'])) resources['css_links'] = list(set(resources['css_links'])) messages = vote_actions['messages'] if not messages: messages = navbars['messages'] user = self.get_binding('user') is_censored = self.get_binding('is_censored') to_hide = self.get_binding('to_hide') result = {} values = { 'idea': self.context, 'is_censored': is_censored, 'to_hide': to_hide, 'state': get_states_mapping(user, self.context, self.context.state[0]), 'current_user': user, 'cant_publish': self._cant_publish_alert(navbars['all_actions'], user), 'cant_submit': self._cant_submit_alert(navbars['all_actions'], user), 'navbar_body': navbars['navbar_body'], 'vote_actions_body': vote_actions['body'] } body = self.content(args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) item['messages'] = messages item['isactive'] = vote_actions['isactive'] or navbars['isactive'] result.update(resources) result['coordinates'] = {self.coordinates: [item]} return result
def __call__(self): user = get_current() guide_tour_data = getattr(user, 'guide_tour_data', {}) guide_state = guide_tour_data.get( 'guide_state', 'first_start') if guide_state in ('pending', 'first_start'): page_resources = get_guide_tour_page( self.request, self.context, user, self.request.view_name) if page_resources: page_resources = merge_dicts( self.resources, page_resources) page_resources['request'] = self.request # if user is not an anonymous if self.request.user: root = getSite() page_resources['update_url'] = self.request.resource_url( root, 'novaideoapi', query={ 'op': 'update_guide_tour_data' }) guide = page_resources.get('guide', None) page = page_resources.get('page', None) if guide is not None and page is not None: guide_data = guide_tour_data.get( guide+'_'+page, {}) page_state = guide_data.get( 'page_state', 'pending') if page_state == 'pending': page_resources['guide'] = guide page_resources['page'] = page page_resources['guide_value'] = guide_data.get( 'guide', -1) page_resources['page_value'] = guide_data.get( 'page', 0) page_resources['guide_state'] = guide_state else: return {} return page_resources return {}
def _update_validated_children(self): result = {} for view in self.validated_children: try: view_result = view.update() except ViewError as e: continue if self.isexecutable and view.isexecutable and \ view.finished_successfully: self.finished_successfully = True #for wizards view.init_stepid() return self.success(view_result) if not isinstance(view_result, dict): return view_result result = merge_dicts(view_result, result) return result
def valid_services(request): site = request.get_site_folder user = get_current() context = request.context allservices = site.get_all_services(context=context, user=user, site=site, validate=True, delegation=False) if hasattr(user, 'get_all_services'): user_services = user.get_all_services(context=context, user=user, site=site, validate=True, delegation=False) allservices = merge_dicts(allservices, user_services) for service in allservices: allservices[service] = list(set(allservices[service])) return allservices
def update(self): self.execute(None) try: navbars = generate_navbars(self.request, self.context) except ObjectRemovedException: return HTTPFound(self.request.resource_url(getSite(), '')) user = self.context current_user = get_current() details = {} stats = get_object_stat(self.context, self.request) stats['nb_other'] = stats.get('nb_other', 0) + len(user.evaluated_objs_ids()) stas_len = sum(stats.values()) evaluation_chart = render_object_evaluation_stat(self.context, self.request) examination_chart = render_object_examination_stat(self.context, self.request) values = { 'user': user, 'proposals': None, 'state': get_states_mapping( current_user, user, getattr(user, 'state_or_none', [None])[0]), 'navbar_body': navbars['navbar_body'], 'actions_bodies': navbars['body_actions'], 'footer_body': navbars['footer_body'], 'is_portal_manager': has_role(role=('PortalManager',)), 'contributions_len': stas_len, 'details': stats, 'evaluation_chart': evaluation_chart, 'examination_chart': examination_chart, } result = {} result = merge_dicts(navbars['resources'], result, ('css_links', 'js_links')) body = self.content(args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) item['messages'] = navbars['messages'] item['isactive'] = navbars['isactive'] result['coordinates'] = {self.coordinates: [item]} return result
def update(self): self.execute(None) navbars = self.get_binding('navbars') root = self.get_binding('root') if navbars is None: return HTTPFound(self.request.resource_url(root, '')) user = self.get_binding('user') to_hide = self.get_binding('to_hide') result = {} values = { 'idea': self.context, 'to_hide': to_hide, 'text': self.context.text.replace('\n', '<br/>'), 'current_user': user, 'footer_body': navbars['footer_body'] } body = self.content(args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) item['isactive'] = True result['coordinates'] = {self.coordinates: [item]} result = merge_dicts(self.requirements_copy, result) return result
def valid_services(request): site = request.get_site_folder user = get_current() context = request.context allservices = site.get_all_services( context=context, user=user, site=site, validate=True, delegation=False) if hasattr(user, 'get_all_services'): user_services = user.get_all_services( context=context, user=user, site=site, validate=True, delegation=False) allservices = merge_dicts(allservices, user_services) for service in allservices: allservices[service] = list(set(allservices[service])) return allservices
def _rendre_comments( self, comments, current_user, origin=False, batch=None, unread_comments=[], filtered=False): all_comments = [] resources = {'css_links': [], 'js_links': []} for obj in comments: try: navbars = generate_listing_menu( self.request, obj, template='novaideo:views/templates/comment_menu.pt') except ObjectRemovedException: continue resources = merge_dicts(navbars['resources'], resources) object_values = { 'context': obj, 'menu_body': navbars['menu_body'], 'primary_menu_body': navbars['primary_menu_body'], 'footer_actions_body': navbars['footer_actions_body'], 'footer_body': navbars['footer_body']} all_comments.append(object_values) all_comments = sorted(all_comments, key=lambda e: e['context'].created_at) values = { 'comments': all_comments, 'unread_comments': unread_comments, 'filtered': filtered, 'current_user': current_user, 'view': self, 'origin': origin, 'batch': batch, 'level': COMMENT_LEVEL } body = self.content(args=values, template=self.template)['body'] return body, resources
def __call__(self): user = get_current() guide_tour_data = getattr(user, 'guide_tour_data', {}) guide_state = guide_tour_data.get('guide_state', 'first_start') if guide_state in ('pending', 'first_start'): page_resources = get_guide_tour_page(self.request, self.context, user, self.request.view_name) if page_resources: page_resources = merge_dicts(self.resources, page_resources) page_resources['request'] = self.request # if user is not an anonymous if self.request.user: root = getSite() page_resources['update_url'] = self.request.resource_url( root, 'novaideoapi', query={'op': 'update_guide_tour_data'}) guide = page_resources.get('guide', None) page = page_resources.get('page', None) if guide is not None and page is not None: guide_data = guide_tour_data.get( guide + '_' + page, {}) page_state = guide_data.get('page_state', 'pending') if page_state == 'pending': page_resources['guide'] = guide page_resources['page'] = page page_resources['guide_value'] = guide_data.get( 'guide', -1) page_resources['page_value'] = guide_data.get( 'page', 0) page_resources['guide_state'] = guide_state else: return {} return page_resources return {}
def update(self): self.execute(None) vote_actions = get_vote_actions_body(self.context, self.request, ballot_ids=['vote_moderation']) try: navbars = generate_navbars(self.request, self.context, process_id='reportsmanagement', descriminators=['plus-action'], flatten=True, text_action=vote_actions['activators']) except ObjectRemovedException: return HTTPFound(self.request.resource_url(getSite(), '')) resources = merge_dicts(navbars['resources'], vote_actions['resources'], ('js_links', 'css_links')) resources['js_links'] = list(set(resources['js_links'])) resources['css_links'] = list(set(resources['css_links'])) messages = vote_actions['messages'] if not messages: messages = navbars['messages'] result = {} values = { 'navbar_body': navbars['navbar_body'], 'object': self.context, 'vote_actions_body': vote_actions['body'] } body = self.content(args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) item['messages'] = messages item['isactive'] = vote_actions['isactive'] or navbars['isactive'] result.update(resources) result['coordinates'] = {self.coordinates: [item]} return result
def _ajax_views(self, request, actions, form_id, ignor_actionsofactions=True, include_resources=True): action_updated = False resources = {} resources['js_links'] = [] resources['css_links'] = [] allbodies_actions = [] updated_view = None valid_form_id = False for (context, action) in actions: #get view class view = DEFAULTMAPPING_ACTIONS_VIEWS[action._class_] #get view instance view_instance = view( context, request, behaviors=[action]) view_result = {} view_has_id = view_instance.has_id(form_id) valid_form_id = valid_form_id or view_has_id #if the view instance is called then update the view if not action_updated and form_id and \ view_has_id: action_updated = True updated_view = view_instance view_result = view_instance() else: #else get view requirements view_result = {'js_links': [], 'css_links': []} if include_resources: view_result = view_instance.get_view_requirements() #if the view instance is executable #and finished successfully return if updated_view is view_instance and \ view_instance.isexecutable and \ view_instance.finished_successfully: return True, True, True, None, None #if the view instance return a result if isinstance(view_result, dict): action_infos = {} #if the view instance is not executable or #it is finished with an error if updated_view is view_instance and \ (not view_instance.isexecutable or \ (view_instance.isexecutable and \ not view_instance.finished_successfully)): action_infos['toreplay'] = True if not view_instance.isexecutable: action_infos['finished'] = True if not ignor_actionsofactions: actions_as = sorted( action.actions, key=lambda call_action: call_action.action.behavior_id) a_actions = [(action, call_action.action) for call_action in actions_as] toreplay, valid_form_id_as, action_updated_as, \ resources_as, allbodies_actions_as = self._ajax_views( request, a_actions, form_id, include_resources) if toreplay: return True, True, True, None, None if action_updated_as: action_updated = True if valid_form_id_as: valid_form_id = True resources['js_links'].extend(resources_as['js_links']) resources['js_links'] = list(set(resources['js_links'])) resources['css_links'].extend(resources_as['css_links']) resources['css_links'] = list(set(resources['css_links'])) action_infos['actions'] = allbodies_actions_as body = '' if 'coordinates' in view_result: body = view_instance.render_item( view_result['coordinates'][view_instance.coordinates][0], view_instance.coordinates, None) action_infos.update( self.action_infomrations(action=action, context=context, request=request)) action_infos.update({ 'body': json.dumps(body), 'context': context, 'assigned_to': sorted( action.assigned_to, key=lambda u: getattr( u, 'title', u.__name__))}) allbodies_actions.append(action_infos) resources = merge_dicts(view_result, resources, ('js_links', 'css_links')) resources['js_links'] = list(set(resources['js_links'])) resources['css_links'] = list(set(resources['css_links'])) if 'finished' in action_infos: view_resources = {} view_resources['js_links'] = [] view_resources['css_links'] = [] view_resources = merge_dicts( view_result, view_resources, ('js_links', 'css_links')) return True, True, True, view_resources, [action_infos] return False, valid_form_id, action_updated, \ resources, allbodies_actions
def update(self): result = {} user = get_current() folderid = self.params('folderid') try: folder = get_obj(int(folderid)) except: folder = None # if not valid folderid if folderid is None or folder is None: error = ViewError() error.principalmessage = _( "Access to the requested folder has been denied") error.causes = [_("Folder not valid")] message = error.render_message(self.request) item = self.adapt_item('', self.viewid) item['messages'] = {error.type: [message]} result['coordinates'] = {self.coordinates: [item]} return result # if permission denied if folder and not can_access(user, folder): error = ViewError() error.principalmessage = _( "Access to the requested folder has been denied") error.causes = [_("Permission denied")] message = error.render_message(self.request) item = self.adapt_item('', self.viewid) item['messages'] = {error.type: [message]} result['coordinates'] = {self.coordinates: [item]} return result classifications = [ CLASSIFICATIONS[fid] for fid in getattr(folder, 'classifications', []) ] classifications.reverse() source_class = None for classification in classifications: source_class = classification(source_class) setattr(self, 'filter_instance', None) filter_body = None filter_form, filter_data = self._add_filter(folder, user) # calling self._add_filter will set self.filter_instance or not template_type = getattr(folder, 'view_type', 'default') if template_type == 'bloc': self.container_css_class = 'home folder-bloc' self.wrapper_template = 'lac:views/admin_process/templates/folder_blocs_view_wrapper.pt' args = merge_with_filter_view(self, {}) objects = get_folder_content(folder, user, **args) len_result = len(objects) self.breadcrumb = self.content( args={ 'lineage': folder.folder_lineage, 'nember': len_result }, template=self.breadcrumb_template)['body'] self.title = '/'.join([f.title for f in folder.folder_lineage]) if getattr(self, 'filter_instance', None) is not None: filter_data['filter_message'] = self.breadcrumb filter_body = getattr(self, 'filter_instance').get_body(filter_data) if source_class is None: url = self.request.resource_url(self.context, 'open', query={'folderid': folderid}) batch = Batch(objects, self.request, url=url, default_size=BATCH_DEFAULT_SIZE) batch.target = "#results" result_body = [] for obj in batch: object_values = { 'object': obj, 'current_user': user, 'state': get_states_mapping( user, obj, getattr(obj, 'state_or_none', [None])[0]) } body = self.content( args=object_values, template=obj.templates[template_type])['body'] result_body.append(body) values = { 'bodies': result_body, 'batch': batch, 'filter_body': filter_body, 'row_len': math.ceil(len_result / 2) } template = self.templates.get(template_type, 'default') body = self.content(args=values, template=template)['body'] else: body = source_class.render(objects, self.request, folder, filter_body=filter_body, validated=getattr( self.filter_instance, 'validated', {}), template_type=template_type) item = self.adapt_item(body, self.viewid) result['coordinates'] = {self.coordinates: [item]} result = merge_dicts(self.requirements_copy, result) if filter_form: result['css_links'] = filter_form['css_links'] result['js_links'] = filter_form['js_links'] return result
def update(self, ): self.init_stepid(self.schema) form, reqts = self._build_form() form.formid = self.viewid + '_' + form.formid set_oid(form.children, form.formid) item = None result = {} posted_formid = None error = False if '__formid__' in self.request.POST: posted_formid = self.request.POST['__formid__'] if posted_formid is not None and posted_formid == form.formid: for button in form.buttons: if button.name in self.request.POST: try: if (button.name in self.behaviors_instances) and \ isinstance(self.behaviors_instances[button.name], Cancel): # bypass form validation for Cancel behavior cancel_beh = self.behaviors_instances[button.name] behaviors = self.behaviors_instances.values() self.remove_tmp_stores(form) cancel_beh.execute(self.context, self.request, {'behaviors': behaviors}) validated = {} else: controls = self.request.POST.items() validated = form.validate(controls) except deform.exception.ValidationFailure as e: fail = getattr(self, '%s_failure' % button.title, None) if fail is None: fail = self._failure item = fail(e, form) error = True else: try: behavior = self.behaviors_instances[button.name] item = behavior.execute(self.context, self.request, validated) self.finished_successfully = True self.remove_tmp_stores(form) except FormError as e: snippet = '<div class="error">Failed: %s</div>' % e self.request.sdiapi.flash(snippet, 'danger', allow_duplicate=True) item = self.adapt_item(form.render(validated), form.formid) error = True break if item is None: if not self.finished_successfully: item = self.show(form) if isinstance(item, dict): if error: item['isactive'] = True result['coordinates'] = {self.coordinates: [item]} result['js_links'] = list(reqts['js']) result['css_links'] = list(reqts['css']) result = merge_dicts(self.requirements_copy, result) else: result = item return result
def update(self): self.execute(None) vote_actions = self.get_binding('vote_actions') navbars = self.get_binding('navbars') root = self.get_binding('root') if navbars is None: return HTTPFound(self.request.resource_url(root, '')) resources = merge_dicts(navbars['resources'], vote_actions['resources'], ('js_links', 'css_links')) resources['js_links'] = list(set(resources['js_links'])) resources['css_links'] = list(set(resources['css_links'])) messages = vote_actions['messages'] if not messages: messages = navbars['messages'] user = self.get_binding('user') is_participant = self.get_binding('is_participant') is_censored = self.get_binding('is_censored') to_hide = self.get_binding('to_hide') title, description, text, add_filigrane = self.get_binding( 'content_data') corrections = self.get_binding('corrections') enable_corrections = self.get_binding('enable_corrections') tinymce_js = 'deform:static/tinymce/tinymce.min.js' if enable_corrections and\ tinymce_js not in resources['js_links']: resources['js_links'].append(tinymce_js) related_ideas = self.context.related_ideas not_published_ideas = [ i for i in related_ideas if 'published' not in i.state ] not_favorable_ideas = [] idea_to_examine = 'idea' in self.request.content_to_examine if idea_to_examine: not_favorable_ideas = [ i for i in related_ideas if 'favorable' not in i.state and 'published' in i.state ] if not self.request.moderate_ideas: not_favorable_ideas.extend(not_published_ideas) result = {} values = { 'proposal': self.context, 'is_censored': is_censored, 'to_hide': to_hide, 'state': get_states_mapping(user, self.context, self.context.state[0]), 'title': title, 'description': description, 'corrections': corrections, 'enable_corrections': enable_corrections, 'current_user': user, 'is_participant': is_participant, 'vote_actions_body': vote_actions['body'], 'cant_publish': self._cant_publish(navbars['all_actions']), 'idea_to_examine': idea_to_examine, 'not_published_ideas': not_published_ideas, 'not_favorable_ideas': not_favorable_ideas, 'ct_participate': self._cant_participate(navbars['all_actions'], user, root), 'wg_body': navbars['wg_body'], 'navbar_body': navbars['navbar_body'], 'json': json } body = self.content(args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) item['messages'] = messages item['isactive'] = vote_actions['isactive'] or navbars['isactive'] result.update(resources) result['coordinates'] = {self.coordinates: [item]} return result
def update(self): if self.request.POST and 'login_form.submitted' in self.request.POST: log_result = self.login() if not isinstance(log_result, dict): return log_result self.execute(None) site = get_site_folder(True) self.title = site.title site_id = get_oid(site) user = get_current() folders = find_entities(interfaces=[ISmartFolder], metadata_filter={'states': ['published']}, force_local_control=True) my_folders = [] if self.request.user: my_folders = getattr(user, 'folders', []) my_folders = [ folder for folder in my_folders if isinstance(folder, SmartFolder) and not folder.parents and 'private' in folder.state ] folders = [ folder for folder in folders if not folder.parents and getattr(folder, 'add_as_a_block', False) ] folders.extend(my_folders) foldersdata = [] old_date = datetime.datetime.now(tz=pytz.UTC) - datetime.timedelta( days=getattr(site, 'days_visibility', DEFAULT_DAYS_VISIBILITY)) old_date = old_date.replace(tzinfo=pytz.UTC) lac_catalog = find_catalog('lac') release_date_index = lac_catalog['release_date'] query = release_date_index.ge(old_date) content_types = getattr( site, 'home_content_types', ['review', 'cinema_review', 'brief', 'interview']) for folder in folders: all_folders = [folder] all_folders.extend(folder.all_sub_folders('published')) contents_oids = set() for sub_folder in all_folders: result_set = get_folder_content(sub_folder, user, sort_on='release_date', reverse=True, limit=MORE_NB, add_query=query, metadata_filter={ 'content_types': content_types, 'states': ['published'] }) contents_oids |= set(result_set.ids) if contents_oids: contents_oids = release_date_index.sort(contents_oids, reverse=True, limit=MORE_NB) objectmap = find_objectmap(get_current_request().root) resolver = objectmap.object_for contents = [resolver(oid) for oid in contents_oids] foldersdata.append({ 'folder': folder, 'contents': contents, 'order': folder.get_order(site_id) }) foldersdata = sorted(foldersdata, key=lambda e: e['order']) result = {} values = { 'folders': foldersdata, 'content_types': content_types, 'row_len': math.ceil(len(foldersdata) / 2) } body = self.content(args=values, template=self.template)['body'] item = self.adapt_item(body, self.viewid) result['coordinates'] = {self.coordinates: [item]} result = merge_dicts(self.requirements_copy, result) return result