class OptionalVenueSchema(VisualisableElementSchema, SearchableEntitySchema):
typ_factory = ObjectData
name = NameSchemaNode(
editing=context_is_a_venue,
)
id = colander.SchemaNode(
colander.String(),
widget=deform.widget.HiddenWidget(),
title="ID",
missing=""
)
title = colander.SchemaNode(
colander.String(),
widget=venue_choice,
title=_('Venue title'),
description=_('Indicate the venue (room, theatre, lecture hall, square, etc.).'),
)
description = colander.SchemaNode(
colander.String(),
widget=RichTextWidget(),
description=_("Vous pouvez ajouter ou éditer la description du lieu. Cette description doit porter sur le lieu de l'annonce et non sur l'annonce."),
title=_("Venue description")
)
addresses = colander.SchemaNode(
colander.Sequence(),
omit(AddressSchema(name='address',
widget=SimpleMappingWidget(
css_class='address-well object-well default-well')),
['_csrf_token_']),
widget=SimpleSequenceWidget(
min_len=1,
add_subitem_text_template=_('Add a new address'),
remove_subitem_text_template=_('Remove the address')),
title=_('Venue addresses'),
)
other_conf = omit(MoreInfoVebueSchema(widget=SimpleMappingtWidget(
mapping_css_class='controled-form'
' object-well hide-bloc',
ajax=True,
control_css_class='optional-venue-form',
activator_css_class="glyphicon glyphicon-map-marker",
activator_title=_("Avez-vous une minute ? Afin d'améliorer la visibilité et la pertinence de votre événement, pensez à vérifier ou compléter les informations associées au lieu en cliquant ici."))),
["_csrf_token_"])
origin_oid = colander.SchemaNode(
colander.Int(),
widget=deform.widget.HiddenWidget(),
title=_('OID'),
missing=0
)
class StructureBaseSchema(VisualisableElementSchema):
"""Schema for Structure"""
structure_name = colander.SchemaNode(
colander.String(),
title=_('Structure name'),
)
domains = colander.SchemaNode(
colander.String(),
widget=LimitedTextAreaWidget(rows=5,
cols=30,
limit=350,
alert_values={'limit': 350},
css_class="ce-field-description"),
title=_("Cultural domains"),
missing="",
)
address = colander.SchemaNode(
colander.Sequence(),
omit(AddressSchema(name='address',
widget=SimpleMappingWidget(
css_class='address-well object-well default-well')),
['_csrf_token_']),
widget=SequenceWidget(
max_len=1,
min_len=1,
add_subitem_text_template=_('Add a new address')),
title=_('Address'),
)
contact = colander.SchemaNode(
colander.Sequence(),
omit(select(ContactSchema(name='contact',
widget=SimpleMappingWidget(
css_class='address-well object-well default-well')),
['person_to_contact', 'public_phone',
'professional_phone', 'fax', 'website']),
['_csrf_token_']),
widget=SequenceWidget(
max_len=1,
min_len=1,
add_subitem_text_template=_('Add a new contact')),
title=_('Contact'),
)
picture = colander.SchemaNode(
ObjectData(Image),
widget=get_file_widget(file_type=['image']),
title=_('Logo'),
required=False,
missing=None,
)
def before_update(self):
if len(self.request.analytics_default_content_types) == 1:
self.schema = omit(self.schema, ['content_types'])
if len(self.request.content_to_examine) == 0:
self.schema = omit(self.schema, [('dates', ['date_of'])])
formwidget = deform.widget.FormWidget(
css_class='analytics-form filter-form')
formwidget.template = 'novaideo:views/templates/ajax_form.pt'
formwidget.ajax_url = self.request.resource_url(
self.context, '@@analyticsapi', query={'op': 'contents_by_dates'})
self.schema.widget = formwidget
def before_update(self):
if len(self.request.analytics_default_content_types) == 1:
self.schema = omit(self.schema, ['content_types'])
if len(self.request.content_to_examine) == 0:
self.schema = omit(self.schema, [('dates', ['date_of'])])
formwidget = deform.widget.FormWidget(
css_class='analytics-form filter-form')
formwidget.template = 'novaideo:views/templates/ajax_form.pt'
formwidget.ajax_url = self.request.resource_url(
self.context, '@@analyticsapi', query={'op': 'contents_by_dates'})
self.schema.widget = formwidget
def before_update(self):
site = self.context
services = site.get_all_services(kinds=['extractionservice'],
delegation=False)
has_extraction = 'extractionservice' in services
if not has_extraction:
self.schema = omit(self.schema, ['pub_conf'])
else:
has_periodic = getattr(services['extractionservice'][0],
'has_periodic', False)
if not has_periodic:
self.schema = omit(self.schema, [('pub_conf', [
'closing_date', 'closing_frequence',
'delay_before_publication', 'publication_number'
])])
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 CreationCulturelleApplicationSchema(VisualisableElementSchema):
"""Schema for application configuration."""
name = NameSchemaNode(editing=context_is_a_root, )
titles = colander.SchemaNode(
colander.Sequence(),
colander.SchemaNode(colander.String(), name=_("Title")),
widget=SequenceWidget(),
default=DEFAULT_TITLES,
title=_('List of titles'),
)
tree = colander.SchemaNode(
typ=DictSchemaType(),
validator=colander.All(keywords_validator),
widget=keyword_widget,
default=DEFAULT_TREE,
title=_('Categories'),
)
organizations = colander.SchemaNode(
colander.Sequence(),
omit(
OrganizationSchema(factory=Organization,
editable=True,
name=_('Organization'),
widget=SimpleMappingWidget(
css_class='object-well default-well'),
omit=['managers']), ['_csrf_token_']),
widget=organizations_choice,
title=_('Organizations'),
)
class PayCulturalEventView(FormView):
title = _('Submit')
name = 'payculturaleventform'
formid = 'formpayculturalevent'
schema = omit(PaySchema(), ['_csrf_token_'])
behaviors = [PayCulturalEvent]
validate_behaviors = False
action = 'https://paiement.systempay.fr/vads-payment/'
def update(self):
payment_confirmation = self.params('payment_confirmation')
if payment_confirmation:
#@TODO traitement du paiment
pass
else:
return super(PayCulturalEventView, self).update()
def before_update(self):
formwidget = deform.widget.FormWidget(css_class='compareform')
formwidget.template = 'lac:views/templates/pay_form.pt'
cancel_url = self.request.resource_url(self.context, '@@index')
formwidget.cancel_url = cancel_url
self.schema.widget = formwidget
def default_data(self):
#@TODO calcul de la signature et des valeur du formulaire
return {'signature': 'testsignature'}
class ServiceDefinitionSchema(VisualisableElementSchema):
"""Schema for service"""
description = colander.SchemaNode(
colander.String(),
widget=LimitedTextAreaWidget(rows=5,
cols=30,
limit=350,
alert_values={'limit': 350},
css_class="ce-field-description"),
description=_('Thank you to enter a description for your service.'),
title=_("Description of the service"),
)
details = colander.SchemaNode(
colander.String(),
widget=RichTextWidget(),
missing="",
description=_('Other information about the service.'),
title=_('Details'),
)
subscription = omit(
SubscriptionSchema(widget=SimpleMappingWidget(
css_class='object-well default-well')), ['_csrf_token_'])
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 ExplanationGroupsSchema(Schema):
groups = colander.SchemaNode(
colander.Sequence(),
omit(
ExplanationGroupSchema(name='Amendment',
widget=DragDropMappingWidget()),
['_csrf_token_']),
widget=groups_widget,
title=_('Group your improvements into amendments'))
single_amendment = colander.SchemaNode(
colander.Boolean(),
widget=deform.widget.CheckboxWidget(
css_class="single-amendment-control"),
label=_('Group the improvements into a single amendment'),
title='',
missing=False)
justification = colander.SchemaNode(
colander.String(),
widget=LimitedTextAreaWidget(
limit=350,
item_css_class="justification-amendment hide-bloc",
placeholder=_("Justification")),
missing="",
title=_("Justification"))
class ContentsByDatesSchema(ContentsByKeywordsSchema):
dates = omit(
IntervalDates(widget=SimpleMappingWidget(css_class="filter-block"
" object-well"
" default-well")),
["_csrf_token_"])
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 SearchableEntitySchema(Schema):
typ_factory = ObjectData
tree = colander.SchemaNode(
typ=DictSchemaType(),
validator=colander.All(keywords_validator),
widget=keyword_widget,
default=DEFAULT_TREE,
title=_('Categories'),
description=_('Indicate the category of the event. Please specify a second keyword level for each category chosen.')
)
metadata = omit(MetadataSchema(widget=SimpleMappingtWidget(
mapping_css_class='controled-form'
' object-well default-well hide-bloc',
control_css_class='alert alert-success',
ajax=True,
activator_css_class="glyphicon glyphicon-cog",
activator_title=_('Manage metadata'))),
["_csrf_token_"])
def deserialize(self, cstruct=colander.null):
appstruct = super(SearchableEntitySchema, self).deserialize(cstruct)
if 'metadata' not in appstruct:
return appstruct
metadata = appstruct.pop('metadata', {})
appstruct.update(metadata)
return appstruct
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'),
)
def before_update(self):
self.schema = omit(select(CalendarSearchSchema(),
['thematics',
'dates',
'artists_ids',
'text_to_search']),
['_csrf_token_'])
class CreateIdeaView(FormView):
title = _('Create an idea')
schema = omit(
select(IdeaSchema(factory=Idea, editable=True, omit=('anonymous', )), [
'challenge', 'title', 'text', 'tree', 'attached_files', 'anonymous'
]), ["_csrf_token_"])
behaviors = [
CrateAndPublishAsProposal, CrateAndPublish, CreateIdea, Cancel
]
formid = 'formcreateidea'
name = 'createidea'
css_class = 'panel-transparent'
def before_update(self):
user = get_current(self.request)
behaviors = [
CrateAndPublishAsProposal, CrateAndPublish, CreateIdea, Cancel
]
if 'proposal' not in self.request.content_to_manage:
behaviors = [CrateAndPublish, CreateIdea, Cancel]
if getattr(self.request, 'moderate_ideas', False):
can_submit = getattr(user, 'can_submit_idea', lambda: True)
if not can_submit():
behaviors.remove(CrateAndPublish)
if len(behaviors) < 4:
self.behaviors = behaviors
self.behaviors_instances = OrderedDict()
specific_behaviors = [
b._class_ for b in self.specific_behaviors_instances
]
self._init_behaviors(specific_behaviors)
self.schema = update_anonymous_schemanode(self.request.root,
self.schema)
self.schema = update_challenge_schemanode(self.request, user,
self.schema)
if not getattr(self, 'is_home_form', False):
self.action = self.request.resource_url(
self.context,
'novaideoapi',
query={
'op': 'update_action_view',
'node_id': CreateIdea.node_definition.id
})
self.schema.widget = deform.widget.FormWidget(
css_class='deform novaideo-ajax-form')
else:
self.action = self.request.resource_url(self.context, 'createidea')
self.schema.widget = deform.widget.FormWidget(
css_class='material-form deform')
def bind(self):
if getattr(self, 'is_home_form', False):
return {'is_home_form': True}
return {}
def before_update(self):
site = get_site_folder(True)
services = site.get_all_services(
kinds=['extractionservice'], delegation=False)
has_extraction = 'extractionservice' in services and\
getattr(services['extractionservice'][0], 'has_periodic', False)
if not has_extraction:
self.schema = omit(self.schema, ['publication_number'])
def before_update(self):
site = self.context
services = site.get_all_services(
kinds=['extractionservice'], delegation=False)
has_extraction = 'extractionservice' in services
if not has_extraction:
self.schema = omit(self.schema, ['pub_conf'])
else:
has_periodic = getattr(
services['extractionservice'][0], 'has_periodic', False)
if not has_periodic:
self.schema = omit(
self.schema,
[('pub_conf', ['closing_date',
'closing_frequence',
'delay_before_publication',
'publication_number'])])
def before_update(self):
site = get_site_folder(True)
services = site.get_all_services(
kinds=['extractionservice'], delegation=False)
has_extraction = 'extractionservice' in services and\
getattr(services['extractionservice'][0], 'has_periodic', False)
if not has_extraction:
self.schema = omit(self.schema, ['publication_number'])
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 {}
class ProposalSchema(VisualisableElementSchema, SearchableEntitySchema):
"""Schema for Proposal"""
name = NameSchemaNode(
editing=context_is_a_proposal,
)
challenge = colander.SchemaNode(
ObjectType(),
widget=challenge_choice,
missing=None,
title=_("Challenge (optional)"),
description=_("You can select and/or modify the challenge associated to this proposal. "
"For an open proposal, do not select anything in the « Challenge » field.")
)
description = colander.SchemaNode(
colander.String(),
validator=colander.Length(max=600),
widget=LimitedTextAreaWidget(rows=5,
cols=30,
limit=600),
title=_("Abstract")
)
text = colander.SchemaNode(
colander.String(),
widget=RichTextWidget(),
title=_("Text")
)
related_ideas = colander.SchemaNode(
colander.Set(),
widget=ideas_choice,
title=_('Related ideas'),
validator=Length(_, min=1),
default=[],
)
add_files = omit(AddFilesSchemaSchema(
widget=SimpleMappingtWidget(
mapping_css_class='controled-form'
' object-well default-well hide-bloc',
ajax=True,
activator_icon="glyphicon glyphicon-file",
activator_title=_('Add files'))),
["_csrf_token_"])
anonymous = colander.SchemaNode(
colander.Boolean(),
widget=anonymous_widget,
label=_('Remain anonymous'),
description=_('Check this box if you want to remain anonymous.'),
title='',
missing=False,
default=False
)
class NewsletterSchema(VisualisableElementSchema):
"""Schema for newsletter"""
typ_factory = ObjectData
name = NameSchemaNode(editing=context_is_a_newsletter, )
subject = colander.SchemaNode(
colander.String(),
title=_('Subject'),
default=default_subject,
description=_('The subject of the newsletter.'))
description = colander.SchemaNode(colander.String(),
widget=deform.widget.TextAreaWidget(
rows=4, cols=60),
title=_("Description"))
content = colander.SchemaNode(
colander.String(),
validator=colander.All(content_validator, ),
widget=RichTextWidget(),
default=default_content,
missing='',
title=_("Content"),
description=_("The content to be sent."),
)
working_params_conf = omit(
NewsletterWorkingParamConf(widget=SimpleMappingtWidget(
mapping_css_class='controled-form'
' object-well default-well',
ajax=True,
activator_icon="glyphicon glyphicon-cog",
activator_title=_('Configure the working parameters'))),
["_csrf_token_"])
rec_conf = omit(
NewsletterRecConf(widget=SimpleMappingtWidget(
mapping_css_class='controled-form'
' object-well default-well',
ajax=True,
activator_icon="glyphicon glyphicon-repeat",
activator_title=_('Configure the recurrence'))), ["_csrf_token_"])
def before_update(self):
if getattr(self.parent, 'is_draft_owner', False):
self.schema = omit(self.schema, ['explanation'])
self.action = self.request.resource_url(
self.context, 'novaideoapi',
query={'op': 'update_action_view',
'node_id': DeleteProposal.node_definition.id})
self.schema.widget = deform.widget.FormWidget(
css_class='deform novaideo-ajax-form')
class CandidatesSchema(Schema):
candidates = colander.SchemaNode(colander.Sequence(),
omit(
CandidateSchema(widget=ObjectWidget(),
editable=True,
name='candidate',
omit=['judgment']),
['_csrf_token_']),
widget=InLineWidget(),
title=_('Candidates'))
class KeywordsConfSchema(Schema):
tree = colander.SchemaNode(
typ=DictSchemaType(),
validator=colander.All(keywords_validator),
widget=keyword_widget,
default=DEFAULT_TREE,
title=_('Categories'),
)
keywords_mapping = omit(KeywordsMappingSchema(widget=SimpleMappingWidget()),
["_csrf_token_"])
class FindFilterSchema(FilterSchema):
metadata_filter = omit(
FindMetadataFilter(widget=SimpleMappingtWidget(
mapping_css_class='controled-form',
ajax=True,
activator_icon="glyphicon glyphicon-cog",
activator_title=_('Metadata filter')),
query=metadata_filter_query,
analyzer=metadata_filter_analyzer,
filter_analyzer=metadata_filter_data),
["_csrf_token_"])
class YammerConnectorSchema(ConnectorSchema):
"""Schema for idea"""
typ_factory = ObjectData
name = NameSchemaNode(editing=context_is_a_yammer, )
auth_conf = omit(
AuthSchema(widget=SimpleMappingtWidget(
mapping_css_class='controled-form object-well',
ajax=True,
activator_icon="glyphicon glyphicon-log-in",
activator_title=_('Configure the autentication policy'))),
["_csrf_token_"])
notif_conf = omit(
NotificationSchema(widget=SimpleMappingtWidget(
mapping_css_class='controled-form object-well',
ajax=True,
activator_icon="glyphicon glyphicon-bell",
activator_title=_('Configure notifications'))), ["_csrf_token_"])
class ScheduleSchema(VisualisableElementSchema):
"""Schema for schedule"""
name = NameSchemaNode(editing=context_is_a_schedule, )
dates = colander.SchemaNode(
colander.String(),
validator=dates_validator,
widget=DateIcalWidget(css_class="schedule-dates"),
description=_('Indicate the dates and hours of the event.'),
title=_('Dates'),
)
ticket_type = colander.SchemaNode(
colander.String(),
widget=ticket_type_choice,
title=_('Ticket type'),
)
ticketing_url = colander.SchemaNode(
colander.String(),
widget=TextInputWidget(item_css_class="hide-bloc item-price"),
title=_('Ticketing URL'),
description=
_('If you have an online ticketing service, you can enter the URL here.'
),
missing='')
price = colander.SchemaNode(
colander.String(),
default='0',
widget=TextInputWidget(item_css_class="hide-bloc item-price"),
title=_('Price'),
)
venue = omit(
select(
OptionalVenueSchema(
editable=True,
factory=Venue,
omit=('id', ),
name='venue',
title=_('Venue'),
oid='venue',
widget=SimpleMappingWidget(
css_class="venue-block",
mapping_title=_("The venue of the event"))), [
'id', 'origin_oid', 'title', 'description',
'addresses', 'other_conf'
]),
#'kind', 'website','phone', 'capacity',
['_csrf_token_', '__objectoid__'])
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 ArtistBlockSchema(Schema):
artist = omit(
select(
ArtistInformationSheetSchema(
editable=True,
omit=('id', ),
widget=SimpleMappingWidget(
css_class=
'artist-data director-data object-well default-well')), [
'id', 'origin_oid', 'title', 'description', 'picture',
'biography', 'is_director'
]), ['_csrf_token_', '__objectoid__'])
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
def before_update(self):
site = get_site_folder(True)
services = site.get_all_services(
kinds=['sellingtickets', 'extractionservice'], delegation=False)
if 'sellingtickets' not in services:
self.schema = omit(self.schema,
['selling_tickets',
('schedules', ['ticketing_url'])])
if 'extractionservice' in services:
self.schema.get('description').description = _(
'Describe succinctly the event.'
' Only this part of the description will '
'be included in the paper version of the magazine.')
def before_update(self):
site = get_site_folder(True)
services = site.get_all_services(
kinds=['sellingtickets', 'extractionservice'], delegation=False)
if 'sellingtickets' not in services:
self.schema = omit(
self.schema,
['selling_tickets', ('schedules', ['ticketing_url'])])
if 'extractionservice' in services:
self.schema.get('description').description = _(
'Describe succinctly the event.'
' Only this part of the description will '
'be included in the paper version of the magazine.')
class InviteUsersSchema(Schema):
invitations = colander.SchemaNode(
colander.Sequence(),
select(omit(InvitationSchema(factory=Invitation,
editable=True,
name='Invitation',
widget=SimpleMappingWidget(css_class='object-well default-well')),
['_csrf_token_']),
['user_title', 'roles', 'first_name',
'last_name','email']),
widget=SequenceWidget(min_len=1),
title=_('The invitations')
)
class MailTemplatesConfigurationSchema(Schema):
mail_templates = colander.SchemaNode(
colander.Sequence(),
omit(select(MailSeqTemplate(name='template',
title=_('E-mail template'),
widget=SimpleMappingWidget(
css_class="object-well default-well mail-template-well mail-template-block")),
['mail_id', 'title', 'languages']),
['_csrf_token_']),
widget=templates_widget,
default=templates_default,
missing=templates_default,
title=_('E-mail templates'),
)
def before_update(self):
site = get_site_folder(True)
is_moderator = has_any_roles(
roles=(('Moderator', site), ('SiteAdmin', site), 'Admin'))
services = self.context.get_all_services(
kinds=['sellingtickets'], delegation=False)
if 'sellingtickets' not in services and not is_moderator:
self.schema = omit(
self.schema,
['selling_tickets',
('schedules', ['ticketing_url'])])
services = site.get_all_services(
kinds=['extractionservice'], delegation=False)
if 'extractionservice' in services:
self.schema.get('description').description = _(
'Describe succinctly the event.'
' Only this part of the description will '
'be included in the paper version of the magazine.')
def other_conf(self):
return self.get_data(omit(OtherSchema(),
'_csrf_token_'))
def notif_conf(self):
return self.get_data(omit(NotificationConfigurationSchema(),
'_csrf_token_'))
def ui_conf(self):
return self.get_data(omit(UserInterfaceConfigurationSchema(),
'_csrf_token_'))
def homepage_conf(self):
return self.get_data(omit(HomepageConfigurationSchema(),
'_csrf_token_'))
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 {}
def keywords_conf(self):
return self.get_data(omit(KeywordsConfSchema(),
'_csrf_token_'))
def mail_conf(self):
return self.get_data(omit(MailTemplatesConfigurationSchema(),
'_csrf_token_'))
def before_update(self):
if getattr(self.parent, 'is_draft_owner', False):
self.schema = omit(self.schema, ['explanation'])
def update_challenge_schemanode(request, user, schema):
if 'challenge' not in request.content_to_manage or \
not len(get_pending_challenges(user)) > 0:
schema = omit(schema, ['challenge'])
return schema
def update_anonymous_schemanode(root, schema):
if not getattr(root, 'anonymisation', False):
return omit(schema, ['anonymous'])
return schema
def default_data(self):
return self.context.get_data(omit(self.schema,
['_csrf_token_', '__objectoid__']))
def filter_conf(self):
result = self.get_data(omit(FilterConfigurationSchema(),
'_csrf_token_'))
return result
def before_update(self):
if 'published' not in self.context.state:
self.schema = omit(self.schema, [('metadata', ['release_date'])])
def auth_conf(self):
return self.get_data(omit(AuthSchema(),
'_csrf_token_'))
def work_conf(self):
result = self.get_data(omit(WorkParamsConfigurationSchema(),
'_csrf_token_'))
return result
def omit_filters(self, filters):
self.schema = omit(FilterSchema(), filters)
def user_conf(self):
return self.get_data(omit(UserParamsConfigurationSchema(),
'_csrf_token_'))
def working_params_conf(self):
return self.get_data(omit(NewsletterWorkingParamConf(),
'_csrf_token_'))
def rec_conf(self):
return self.get_data(omit(NewsletterRecConf(),
'_csrf_token_'))
def before_update(self):
if not has_role(role=('Admin', )):
self.schema = omit(
self.schema,
[('user_conf', ['only_for_members'])])
def pub_conf(self):
return self.get_data(omit(PublicationConfigurationSchema(),
'_csrf_token_'))
