def before_update(self):
root = getSite()
if getattr(self.context.working_group, 'work_mode', None):
self.schema = select(PublishProposalSchema(), ['vote', 'elected', 'members_to_invite'])
can_submit_directly = getattr(root, 'can_submit_directly', False)
if not can_submit_directly:
self.schema = select(
PublishProposalSchema(), ['work_mode', 'elected', 'members_to_invite'])
duration_ballot = self.context.working_group.duration_configuration_ballot
vp_ballot = self.context.working_group.vp_ballot
duration_ballot_report = duration_ballot.report if duration_ballot else None
vp_ballot_report = vp_ballot.report if vp_ballot else None
subjects_widget = subjects_choice(duration_ballot_report)
elected_node = self.schema.get('elected')
elected_node.title = getattr(duration_ballot_report.ballottype,
'group_title', _('Choices'))
group_default = getattr(duration_ballot_report.ballottype,
'group_default', None)
if group_default:
elected_node.default = group_default
elected_node.widget = subjects_widget
if can_submit_directly:
vote_widget = vote_choice(vp_ballot_report)
self.schema.get('vote').widget = vote_widget
self.schema.view = self
self.action = self.request.resource_url(
self.context, 'novaideoapi',
query={'op': 'update_action_view',
'node_id': PublishProposal.node_definition.id})
self.schema.widget = deform.widget.FormWidget(
css_class='deform novaideo-ajax-form publish-proposal-form')
class EditView(FormView):
title = _('Edit the profile')
schema = select(
EditPersonSchema(factory=Person,
editable=True,
omit=('keywords', 'change_password')), [
'user_title', 'first_name', 'last_name', 'email',
'locale', 'keywords', 'picture', 'signature',
'change_password', 'structure', 'company'
])
behaviors = [Edit, Cancel]
formid = 'formedit'
name = 'edit'
requirements = {
'css_links': [],
'js_links': [
'lac:static/js/addresse_management.js',
'lac:static/js/user_management.js'
]
}
def before_update(self):
user = get_current()
if not getattr(user, 'is_cultural_animator', False):
self.schema.children.remove(self.schema.get('structure'))
if not has_role(role=('Advertiser', ), ignore_superiors=True):
self.schema.children.remove(self.schema.get('company'))
def default_data(self):
return self.context
class EditInvitationView(FormView):
title = _('Edit the invitation')
schema = select(InvitationSchema(editable=True), [
'title', 'user_title', 'roles', 'first_name', 'last_name', 'email',
'organization'
])
behaviors = [EditInvitation, Cancel]
formid = 'formeditinvitation'
name = 'editinvitation'
def before_update(self):
if not has_role(role=('Moderator', )):
self.schema = select(
InvitationSchema(editable=True),
['title', 'user_title', 'first_name', 'last_name', 'email'])
self.action = self.request.resource_url(
self.context,
'novaideoapi',
query={
'op': 'update_action_view',
'node_id': EditInvitation.node_definition.id
})
self.schema.widget = deform.widget.FormWidget(
css_class='deform novaideo-ajax-form')
def default_data(self):
return self.context
class CreateProposalFormView(FormView):
title = _('Create a proposal')
schema = select(
ProposalSchema(factory=Proposal,
editable=True,
omit=['related_ideas', 'add_files', 'anonymous']), [
'challenge', 'title', 'description', 'keywords',
'text', 'anonymous', 'related_ideas',
('add_files', ['attached_files'])
])
behaviors = [CreateProposal, Cancel]
formid = 'formcreateproposal'
name = 'createproposal'
css_class = 'panel-transparent'
def before_update(self):
user = get_current(self.request)
self.schema = update_anonymous_schemanode(self.request.root,
self.schema)
self.schema = update_challenge_schemanode(self.request, user,
self.schema)
ideas_widget = ideas_choice(self.context, self.request)
ideas_widget.item_css_class = 'hide-bloc'
ideas_widget.css_class = 'controlled-items'
self.schema.get('related_ideas').widget = ideas_widget
def before_update(self):
self.schema = omit(select(CalendarSearchSchema(),
['thematics',
'dates',
'artists_ids',
'text_to_search']),
['_csrf_token_'])
class EditAnswerFormView(FormView):
title = _('Edit the answer')
schema = select(
AnswerSchema(factory=Answer,
editable=True,
omit=('associated_contents', )),
['files', 'associated_contents', 'option', 'comment'])
behaviors = [EditAnswer, Cancel]
formid = 'formeditanswer'
wrapper_template = 'pontus:templates/views_templates/simple_view_wrapper.pt'
name = 'editAnswer'
def before_update(self):
options = getattr(self.context.question, 'options', [])
if options:
self.schema.get('option').widget = options_choice(options)
else:
self.schema.children.remove(self.schema.get('option'))
self.action = self.request.resource_url(
self.context,
'novaideoapi',
query={
'op': 'update_action_view',
'node_id': EditAnswer.node_definition.id
})
self.schema.widget = deform.widget.FormWidget(
css_class=
'commentform comment-inline-form answerform novaideo-ajax-form deform'
)
def default_data(self):
return self.context
class AnswerQuestionFormView(FormView):
title = _('Answer the question')
schema = select(
AnswerSchema(factory=Answer,
editable=True,
omit=('associated_contents', 'anonymous')),
['files', 'associated_contents', 'option', 'comment', 'anonymous'])
behaviors = [AnswerQuestion, Cancel]
formid = 'formanswerquestion'
wrapper_template = 'pontus:templates/views_templates/simple_view_wrapper.pt'
name = 'answerQuestion'
def before_update(self):
self.schema = update_anonymous_schemanode(self.request.root,
self.schema)
options = getattr(self.context, 'options', [])
if options:
self.schema.get('option').widget = options_choice(options)
else:
self.schema.children.remove(self.schema.get('option'))
self.action = self.request.resource_url(
self.context,
'novaideoapi',
query={
'op': 'update_action_view',
'node_id': AnswerQuestion.node_definition.id
})
self.schema.widget = deform.widget.FormWidget(
css_class=
'commentform comment-inline-form answerform novaideo-ajax-form deform'
)
class CommentIdeaFormView(FormView):
title = _('Discuss the idea')
schema = select(
CommentSchema(factory=Comment,
editable=True,
omit=('associated_contents', 'anonymous')),
['comment', 'intention', 'files', 'associated_contents', 'anonymous'])
behaviors = [CommentIdea]
formid = 'formcommentidea'
name = 'commentideaform'
def before_update(self):
self.schema = update_anonymous_schemanode(self.request.root,
self.schema)
self.action = self.request.resource_url(
self.context,
'novaideoapi',
query={
'op': 'update_action_view',
'node_id': CommentIdea.node_definition.id
})
formwidget = deform.widget.FormWidget(css_class='commentform deform')
formwidget.template = 'novaideo:views/templates/ajax_form.pt'
self.schema.widget = formwidget
class CreateModerationServiceView(FormView):
title = _('Create a moderation service')
schema = select(ModerationServiceSchema(), ['title', 'delegate'])
behaviors = [CreateModerationService, Cancel]
formid = 'formcreatemoderationservice'
name = 'createmoderationservice'
validate_behaviors = False
class EditSmartFolderView(FormView):
title = _('Edit the topic of interest')
schema = select(
SmartFolderSchema(factory=SmartFolder, editable=True),
[
'title',
'description',
'locale',
'cover_picture',
'view_type',
'icon_data',
# 'style',
'filters',
'contents'
])
behaviors = [EditSmartFolder, Cancel]
formid = 'formeditsmartfolder'
name = 'editsmartfolder'
css_class = 'panel-transparent'
def before_update(self):
self.action = self.request.resource_url(
self.context,
'novaideoapi',
query={
'op': 'update_action_view',
'node_id': EditSmartFolder.node_definition.id
})
self.schema.widget = deform.widget.FormWidget(
css_class='deform novaideo-ajax-form')
def default_data(self):
return self.context
class RespondView(FormView):
title = _('Answer')
schema = select(
CommentSchema(factory=Comment,
editable=True,
omit=('associated_contents', 'anonymous')),
['comment', 'intention', 'files', 'associated_contents', 'anonymous'])
behaviors = [Respond]
formid = 'formrespond'
name = 'respond'
requirements = {
'css_links': [],
'js_links': ['novaideo:static/js/comment.js']
}
def before_update(self):
self.schema = update_anonymous_schemanode(self.request.root,
self.schema)
self.action = self.request.resource_url(self.context,
'novaideoapi',
query={
'op':
'update_action_view',
'node_id':
Respond.node_definition.id
})
formwidget = deform.widget.FormWidget(
css_class='commentform comment-inline-form respondform deform')
formwidget.template = 'novaideo:views/templates/ajax_form.pt'
self.schema.widget = formwidget
class EventsInterfaceConfigurationSchema(Schema):
nb_event_maxi = colander.SchemaNode(
colander.Integer(),
title=_('Maximum number of events per Member'),
default=7,
)
event_descriptions = colander.SchemaNode(
colander.Sequence(),
omit(
select(
EventDescriptionTemplate(
name='description',
title=_('Description'),
widget=SimpleMappingWidget(
css_class=
"object-well default-well mail-template-well mail-template-block"
)), ['locale', 'template']), ['_csrf_token_']),
widget=SequenceWidget(
min_len=1,
max_len=len(AVAILABLE_LANGUAGES),
add_subitem_text_template=_('Add a new description')),
title=_('Descriptions'),
default=descriptions_default)
class UnsubscribeNewsletterView(FormView):
title = _('Unsubscribe')
schema = select(UnsubscribeSchema(), ['email'])
behaviors = [UnsubscribeNewsletter, Cancel]
formid = 'formunsubscribenewsletter'
name = 'unsubscribenewsletter'
class CreateCinemaReviewView(FormView):
title = _('Create a review')
schema = select(
CinemaReviewSchema(factory=CinemaReview,
editable=True,
omit=('artists', 'artists_ids', 'directors',
'directors_ids', 'metadata')),
[
'title', 'surtitle', 'tree', 'duration', 'directors',
'directors_ids', 'artists_ids', 'artists', 'nationality',
'picture', 'article', 'appreciation', 'opinion', 'signature',
'informations', 'showcase_review',
('metadata', [
'accessibility', 'object_labels', 'connections_to',
'visibility_dates'
])
])
behaviors = [CreateCinemaReview, Cancel]
formid = 'formcreatecinemareview'
name = 'createcinemareview'
requirements = {
'css_links': [],
'js_links': [
'lac:static/js/artist_management.js',
'lac:static/js/director_management.js'
]
}
class ImproveArtistInformationSheetView(FormView):
title = _('Improve the artist information sheet')
schema = select(
ArtistInformationSheetSchema(factory=ArtistInformationSheet,
editable=True,
omit=('metadata', )),
[
'title', 'description', 'picture', 'biography', 'is_director',
('metadata', ['object_labels', 'connections_to'])
])
behaviors = [ImproveArtistInformationSheet, Cancel]
formid = 'formimproveartistinformationsheet'
name = 'improveartistinformationsheet'
def default_data(self):
source = self.params('source')
context = self.context
if source:
context = get_obj(int(source))
result = context.get_data(
omit(self.schema, ['_csrf_token_', '__objectoid__']))
if result['picture']:
picture = result['picture']
result['picture'] = picture.get_data(None)
return result
class EditOrganizationsView(FormView):
title = _('Edit organizations')
schema = select(NovaIdeoApplicationSchema(),
[(u'organizations', ['title',
'description',
'logo',
'cover_picture',
'managers',
'contacts'])])
behaviors = [EditOrganizations, Cancel]
formid = 'formeditorganizations'
name = 'editorganizations'
css_class = 'panel-transparent'
def default_data(self):
result = {}
organizations = []
for organization in self.context.organizations:
organization_data = organization.get_data(
self.schema.get('organizations').children[0])
organization_data[OBJECT_OID] = str(get_oid(organization))
if organization_data['logo']:
logo = organization_data['logo']
organization_data['logo'] = logo.get_data(None)
organizations.append(organization_data)
result['organizations'] = organizations
return result
class EditView(FormView):
title = _('Edit the profile')
schema = select(
EditPersonSchema(factory=Person,
editable=True,
omit=('change_password', 'organization')),
[
'organization', 'function', 'description', 'tree', 'picture',
'cover_picture', 'email', 'locale', 'change_password'
])
behaviors = [Edit, Cancel]
formid = 'formedit'
name = 'edit'
css_class = "panel-transparent"
requirements = {
'css_links': [],
'js_links': ['novaideo:static/js/user_management.js']
}
def before_update(self):
user = get_current(self.request)
if self.context is not user and \
getattr(self.context, 'pseudonym', ''):
self.schema = omit(self.schema, ['email'])
def default_data(self):
return self.context
class LabelsSchema(Schema):
labels = colander.SchemaNode(
colander.Set(),
widget=labels_choices,
title=_('Labels'),
description=_('You can add labels to this object.'),
default=[],
missing=[]
)
new_labels = colander.SchemaNode(
colander.Sequence(),
omit(select(LabelSchema(
name='new_label',
factory=Label,
editable=True,
widget=SimpleMappingWidget(
css_class='label-well object-well default-well')),
['title', 'picture']),
['_csrf_token_']),
widget=SequenceWidget(
add_subitem_text_template=_('Add a new label')),
title=_('New labels'),
)
class UserEditOrganizationView(FormView):
title = _('Edit the organization')
schema = select(UserEditOrganizationSchema(),
['organization', 'ismanager'])
behaviors = [UserEditOrganization, Cancel]
formid = 'formusereditorganization'
name = 'usereditorganization'
def before_update(self):
self.action = self.request.resource_url(
self.context,
'novaideoapi',
query={
'op': 'update_action_view',
'node_id': UserEditOrganization.node_definition.id
})
self.schema.widget = deform.widget.FormWidget(
css_class='deform novaideo-ajax-form')
def default_data(self):
organization = self.context.organization
if organization:
return {
'organization':
organization,
'ismanager':
has_role(('OrganizationResponsible', organization),
self.context,
ignore_superiors=True)
}
return {}
class EditInterviewView(FormView):
title = _('Edit the interview')
schema = select(InterviewSchema(factory=Interview,
editable=True,
omit=('artists_ids', 'artists', 'metadata')),
['title', 'review', 'tree', 'artists_ids', 'artists',
'picture', 'article',
'signature', 'informations',
'showcase_review',
('metadata', ['accessibility', 'object_labels', 'connections_to'])])
behaviors = [EditInterview, Cancel]
formid = 'formmoderationeditinterview'
name = 'moderationeditinterview'
requirements = {'css_links': [],
'js_links': ['lac:static/js/artist_management.js']}
def default_data(self):
result = self.context.get_data(self.schema)
result['artists'] = get_artist_data(
result['artists'], self.schema.get('artists').children[0])
picture = get_file_data(result['picture'])
result.update(picture)
result[OBJECT_OID] = get_oid(self.context)
return result
class SubscribeNewsletterView(FormView):
title = _('Subscribe')
schema = select(SubscribeSchema(),
['first_name', 'last_name', 'email', 'newsletters'])
behaviors = [SubscribeNewsletter, Cancel]
formid = 'formsubscribenewsletter'
name = 'subscribenewsletter'
css_class = 'panel-transparent'
def default_data(self):
user = get_current()
site = getSite()
newsletters = [n for n in site.newsletters if n.is_subscribed(user)]
return {
'first_name': getattr(user, 'first_name', ''),
'last_name': getattr(user, 'last_name', ''),
'email': getattr(user, 'email', ''),
'newsletters': newsletters
}
def before_update(self):
self.action = self.request.resource_url(
self.context,
'novaideoapi',
query={
'op': 'update_action_view',
'node_id': SubscribeNewsletter.node_definition.id
})
self.schema.widget = deform.widget.FormWidget(
css_class='deform novaideo-ajax-form')
class MailSeqTemplate(Schema):
mail_id = colander.SchemaNode(
colander.String(),
widget=deform.widget.HiddenWidget(),
title=_('Mail id'),
)
title = colander.SchemaNode(
colander.String(),
widget=deform.widget.TextInputWidget(template='readonly/textinput'),
title=_('Title'),
missing=""
)
languages = colander.SchemaNode(
colander.Sequence(),
omit(select(MailTemplate(name='language',
title=_('language'),
widget=SimpleMappingWidget(
css_class="object-well default-well mail-template-well mail-template-block")),
['locale', 'subject', 'template']),
['_csrf_token_']),
widget=SequenceWidget(
min_len=1,
max_len=len(AVAILABLE_LANGUAGES),
add_subitem_text_template=_('Add a new language')),
title=_('Languages'),
)
class FilterConfigurationSchema(Schema):
filters = colander.SchemaNode(
colander.Sequence(),
omit(select(FilterSchema(name='filter',
title=_('Filter'),
widget=SimpleMappingWidget(
css_class="object-well default-well mail-template-well mail-template-block")),
['metadata_filter', 'geographic_filter',
'temporal_filter', 'contribution_filter',
'text_filter', 'other_filter']),
["_csrf_token_"]),
title=_('Filters'),
widget=SequenceWidget(
min_len=1,
add_subitem_text_template=_('Add a new filter')))
hold_filter = colander.SchemaNode(
colander.Boolean(),
widget=deform.widget.CheckboxWidget(),
label=_('Keep the filter after sign in'),
title='',
default=True,
missing=True
)
class EditSmartFolderView(FormView):
title = _('Edit the smart folder')
schema = select(SmartFolderSchema(factory=SmartFolder, editable=True),
['title',
'description',
'filters',
'view_type',
'classifications',
'icon_data',
'style',
'add_as_a_block'])
behaviors = [EditSmartFolder, Cancel]
formid = 'formeditsmartfolder'
name = 'editsmartfolder'
requirements = {'css_links':[],
'js_links':['lac:static/js/smart_folder_management.js',
'lac:static/js/contextual_help_smart_folder.js']}
def before_update(self):
if self.context.parents:
self.schema.children.remove(self.schema.get('add_as_a_block'))
def default_data(self):
return self.context
class EditFilmSynopsesView(FormView):
title = _('Edit the film synopsis')
schema = select(
FilmSynopsesSchema(omit=('artists_ids', 'artists', 'directors',
'directors_ids', 'metadata')),
[
'title', 'film_release_date', 'duration', 'directors',
'directors_ids', 'artists_ids', 'artists', 'nationality',
'picture', 'tree', 'abstract', 'informations',
('metadata', ['object_labels', 'connections_to'])
])
behaviors = [EditFilmSynopses, Cancel]
formid = 'formeditfilmsynopses'
name = 'editfilmsynopses'
requirements = {
'css_links': [],
'js_links': [
'lac:static/js/artist_management.js',
'lac:static/js/director_management.js'
]
}
def default_data(self):
result = self.context.get_data(self.schema)
result['artists'] = get_artist_data(
result['artists'],
self.schema.get('artists').children[0])
result['directors'] = get_artist_data(
result['directors'],
self.schema.get('directors').children[0])
picture = get_file_data(result['picture'])
result.update(picture)
return result
class AddIdeaSchema(Schema):
idea = colander.SchemaNode(
ObjectType(),
widget=idea_choice,
title=_('Re-use one or more existing idea(s)'),
missing=None,
#description=_('Choose an idea')
)
new_idea_choice = colander.SchemaNode(
colander.Boolean(),
widget=deform.widget.CheckboxWidget(css_class="new-idea-control"),
label=_('Add a new idea'),
title='',
missing=False
)
new_idea = select(IdeaSchema(factory=Idea,
editable=True,
omit=['keywords'],
widget=SimpleMappingtWidget(
mapping_css_class='hide-bloc new-idea-form',
ajax=False)),
['challenge',
'title',
'text',
'keywords'])
class EditQuestionFormView(FormView):
title = _('Edit the question')
schema = select(QuestionSchema(),
['title',
'text',
'options',
'keywords',
'attached_files'])
behaviors = [EditQuestion, Cancel]
formid = 'formeditquestion'
wrapper_template = 'pontus:templates/views_templates/simple_view_wrapper.pt'
name = 'editQuestion'
def before_update(self):
if self.context.answers:
self.schema.children.remove(
self.schema.get('options'))
self.action = self.request.resource_url(
self.context, 'novaideoapi',
query={'op': 'update_action_view',
'node_id': EditQuestion.node_definition.id})
self.schema.widget = deform.widget.FormWidget(
css_class='deform novaideo-ajax-form')
def default_data(self):
return self.context
class CorrectProposalFormView(FormView):
title = _('Edit the proposal')
schema = select(ProposalSchema(),
['title',
'description',
'keywords',
'text',
'related_ideas',
'add_files'
])
behaviors = [CorrectProposal, Cancel]
formid = 'formcorrectproposal'
name = 'correctproposalform'
css_class = 'panel-transparent'
def default_data(self):
data = self.context.get_data(self.schema)
attached_files = self.context.attached_files
if attached_files:
data['add_files'] = {'ws_files': attached_files}
return data
def before_update(self):
ideas_widget = ideas_choice(self.context, self.request)
ideas_widget.item_css_class = 'hide-bloc'
ideas_widget.css_class = 'controlled-items'
self.schema.get('related_ideas').widget = ideas_widget
class PresentChallengeFormView(FormView):
title = _('Transmit the challenge to others')
schema = select(PresentChallengeSchema(),
['members', 'subject', 'message', 'send_to_me'])
behaviors = [PresentChallenge]
formid = 'formpresentchallengeform'
name = 'presentchallengeform'
def before_update(self):
self.action = self.request.resource_url(
self.context,
'novaideoapi',
query={
'op': 'update_action_view',
'node_id': PresentChallenge.node_definition.id
})
formwidget = deform.widget.FormWidget(css_class='presentform')
formwidget.template = 'novaideo:views/templates/ajax_form.pt'
self.schema.widget = formwidget
def bind(self):
user = get_current(self.request)
root = self.request.root
mail_template = root.get_mail_template('presentation_challenge',
user.user_locale)
return {'mail_template': mail_template}
class EditView(FormView):
title = _('Edit')
schema = select(
CommentSchema(factory=Comment,
editable=True,
omit=('associated_contents', )),
['comment', 'intention', 'files', 'associated_contents'])
behaviors = [Edit]
formid = 'formedit'
name = 'edit'
requirements = {
'css_links': [],
'js_links': ['novaideo:static/js/comment.js']
}
def default_data(self):
return self.context
def before_update(self):
self.action = self.request.resource_url(self.context,
'novaideoapi',
query={
'op':
'update_action_view',
'node_id':
Edit.node_definition.id
})
formwidget = deform.widget.FormWidget(
css_class='commentform comment-inline-form edit-comment-form deform'
)
formwidget.template = 'novaideo:views/templates/ajax_form.pt'
self.schema.widget = formwidget
def __call__(self):
root = getSite()
search_action, search_view = _getaction(self,
'novaideoviewmanager',
'search')
search_view_instance = search_view(root, self.request,
behaviors=[search_action])
search_view_instance.viewid = 'usermenu' + search_view_instance.viewid
posted_formid = None
if self.request.POST :
if '__formid__' in self.request.POST:
posted_formid = self.request.POST['__formid__']
if posted_formid and \
posted_formid.startswith(search_view_instance.viewid):
search_view_instance.postedform = self.request.POST.copy()
self.request.POST.clear()
search_view_instance.schema = select(search_view_instance.schema,
['text_to_search'])
search_view_result = search_view_instance()
search_body = ''
if isinstance(search_view_result, dict) and \
'coordinates' in search_view_result:
search_body = search_view_instance.render_item(
search_view_result['coordinates'][search_view_instance.coordinates][0],
search_view_instance.coordinates,
None)
result = {}
result['search_body'] = search_body
result['view'] = self
return result
def before_update(self):
if not self.request.user:
self.schema = select(CalendarSearchSchema(), [
'thematics', 'city', 'dates', 'artists_ids', 'text_to_search'
])
return super(AdvancedSearchView, self).before_update()
def before_update(self):
if not self.request.user:
self.schema = select(CalendarSearchSchema(),
['thematics', 'city',
'dates',
'artists_ids',
'text_to_search'])
return super(AdvancedSearchView, self).before_update()
def mutate(root, args, context, info):
comment_schema = select(
CommentSchema(), ['comment', 'files', 'anonymous'])
args = dict(args)
action_id = args.pop('action')
context_oid = args.pop('context')
attached_files = args.pop('attached_files', None)
uploaded_files = []
if attached_files:
for index, file_ in enumerate(attached_files):
file_storage = context.POST.get(
'variables.attachedFiles.'+str(index))
fp = file_storage.file
fp.seek(0)
uploaded_files.append({
'fp': fp,
'filename': urllib.parse.unquote(file_storage.filename)})
args['files'] = uploaded_files
args = comment_schema.deserialize(args)
args['files'] = [f['_object_data']
for f in args['files']]
args['context'] = context_oid
args['intention'] = 'Remark' # TODO the intention must be submitted by the user
context, request, action, args = get_execution_data(
action_id, args)
new_comment = None
if action:
anonymous = args.get('anonymous', False)
new_comment = CommentClass(**args)
appstruct = {
'_object_data': new_comment,
'anonymous': anonymous
}
action.execute(context, request, appstruct)
else:
raise Exception(
request.localizer.translate(_("Authorization failed")))
status = new_comment is not None
return CommentObject(comment=new_comment, status=status)
def mutate(root, args, context, info):
idea_schema = select(
IdeaSchema(), ['title', 'text', 'keywords', 'attached_files', 'anonymous'])
args = dict(args)
attached_files = args.pop('attached_files', None)
uploaded_files = []
if attached_files:
for index, file_ in enumerate(attached_files):
file_storage = context.POST.get(
'variables.attachedFiles.'+str(index))
fp = file_storage.file
fp.seek(0)
uploaded_files.append({
'fp': fp,
'filename': urllib.parse.unquote(file_storage.filename)})
args['attached_files'] = uploaded_files
args = idea_schema.deserialize(args)
args['attached_files'] = [f['_object_data']
for f in args['attached_files']]
context, request, action, args = get_execution_data(
CreateAndPublishIdea.action_id, args)
new_idea = None
if action:
anonymous = args.pop('anonymous', False)
new_idea = IdeaClass(**args)
appstruct = {
'_object_data': new_idea,
'anonymous': anonymous
}
action.execute(context, request, appstruct)
else:
raise Exception(
request.localizer.translate(_("Authorization failed")))
status = new_idea is not None
return CreateAndPublishIdea(idea=new_idea, status=status)
def __init__(self,
context,
request,
parent=None,
wizard=None,
stepid=None,
**kwargs):
super(FilterView, self).__init__(context,
request,
parent,
wizard,
stepid,
**kwargs)
self.error = False
self.validated = {}
self._validated = {}
if self.params('filter_result') is not None or \
kwargs.get('filter_result', None) is not None:
self.calculate_posted_filter()
self.schema = select(FilterSchema(),
['metadata_filter',
('temporal_filter', ['negation', 'created_date']),
'contribution_filter', 'text_filter'])
def before_update(self):
self.schema = select(SearchSchema(), ['text_to_search'])
root = getSite()
self.action = self.request.resource_url(
root, '@@search_result')
def select_filters(self, filters):
self.schema = select(FilterSchema(), filters)
def start(self, context, request, appstruct, **kw):
datas = context.get_data(select(omit(InvitationSchema(),
['_csrf_token_']),
['user_title',
'roles',
'first_name',
'last_name',
'email',
'organization']))
roles = datas.pop('roles')
password = appstruct['password']
datas['locale'] = my_locale_negotiator(request)
person = Person(password=password, **datas)
root = getSite(context)
principals = find_service(root, 'principals')
users = principals['users']
name = person.first_name + ' ' + person.last_name
name = name_chooser(users, name=name)
users[name] = person
if getattr(context, 'ismanager', False) and \
context.organization:
grant_roles(person, (('OrganizationResponsible',
context.organization),))
person.state.append('active')
grant_roles(person, roles)
grant_roles(person, (('Owner', person),))
manager = context.manager
root.delfromproperty('invitations', context)
root.addtoproperty('news_letter_members', person)
newsletters = root.get_newsletters_automatic_registration()
email = getattr(person, 'email', '')
if newsletters and email:
for newsletter in newsletters:
newsletter.subscribe(
person.first_name, person.last_name, email)
context.person = person
if manager:
mail_template = root.get_mail_template(
'accept_invitation',
getattr(manager, 'user_locale', root.locale))
localizer = request.localizer
email_data = get_user_data(person, 'user', request)
novaideo_title = request.root.title
roles_translate = [localizer.translate(APPLICATION_ROLES.get(r, r))
for r in roles]
subject = mail_template['subject'].format(
novaideo_title=novaideo_title,
**email_data
)
email_data.update(get_user_data(manager, 'recipient', request))
email_data.update(get_entity_data(person, 'user', request))
message = mail_template['template'].format(
roles=", ".join(roles_translate),
novaideo_title=novaideo_title,
**email_data)
alert('email', [root.get_site_sender()], [manager.email],
subject=subject, body=message)
return {}
