def update_template(template, title, data, is_clonable, backside_template_id=None, clear_background=False):
"""Update an existing template.
:param template: The template to be updated
:param title: An `EventType` value
:param data: A dict containing the template data (width, height, items, etc)
:param is_clonable: Whether it is possible to clone this template
:param backside_template_id: The ID of the template used as a backside
:param clear_background: Whether to remove the background image of the
template
"""
if template.data['width'] != data['width'] or template.data['height'] != data['height']:
query = DesignerTemplate.query.filter(DesignerTemplate.backside_template == template)
for tpl in query:
tpl.backside_template = None
if tpl.event:
tpl.event.log(EventLogRealm.event, EventLogKind.negative, 'Designer', 'Backside removed',
session.user, data={'Template': tpl.title,
'Reason': 'Dimensions of backside changed',
'Backside': template.title})
template.title = title
template.data = dict({'background_position': 'stretch', 'items': []}, **data)
template.backside_template = DesignerTemplate.get(backside_template_id) if backside_template_id else None
template.is_clonable = is_clonable
if clear_background:
template.background_image = None
if template.event:
template.event.log(EventLogRealm.event, EventLogKind.positive, 'Designer', 'Badge template updated',
session.user, data={'Template': template.title})
def _process(self):
title = "{} (copy)".format(self.template.title)
new_template = DesignerTemplate(title=title, type=self.template.type, data=self.template.data,
**self.target_dict)
if self.template.background_image:
background = self.template.background_image
new_background = DesignerImageFile(filename=background.filename, content_type=background.content_type,
template=new_template)
with background.open() as f:
new_background.save(f)
else:
new_background = None
new_template.background_image = new_background
flash(_("Created copy of template '{}'").format(self.template.title), 'success')
return jsonify_data(html=_render_template_list(self.target, event=self.event_or_none))
def _process(self):
db.session.delete(self.template)
root = Category.get_root()
if not root.default_ticket_template:
# if we deleted the root category's default template, pick
# a system template as the new default (this always exists)
system_template = DesignerTemplate.find_first(DesignerTemplate.is_system_template,
DesignerTemplate.type == TemplateType.badge)
root.default_ticket_template = system_template
db.session.flush()
flash(_('The template has been deleted'), 'success')
return jsonify_data(html=_render_template_list(self.target, event=self.event_or_none))
def _process(self):
template = DesignerTemplate.get_one(request.view_args['template_id'])
if template not in get_all_templates(self.category):
raise Exception('Invalid template')
if template == self.category.default_ticket_template:
# already the default -> clear it
self.category.default_ticket_template = None
elif template == get_default_template_on_category(self.category, only_inherited=True):
# already the inherited default -> clear it instead of setting it explicitly
self.category.default_ticket_template = None
else:
self.category.default_ticket_template = template
if self.category.is_root and not self.category.default_ticket_template:
raise Exception('Cannot clear default ticket template on root category')
return jsonify_data(html=_render_template_list(self.category))
def _process(self):
template = DesignerTemplate.get_or_404(request.view_args['template_id'])
all_ticket_templates = [tpl for tpl in get_all_templates(self.category)
if tpl.type == TemplateType.badge and tpl.is_ticket]
if template not in all_ticket_templates:
raise Exception('Invalid template')
if template == self.category.default_ticket_template:
# already the default -> clear it
self.category.default_ticket_template = None
elif template == get_default_ticket_on_category(self.category, only_inherited=True):
# already the inherited default -> clear it instead of setting it explicitly
self.category.default_ticket_template = None
else:
self.category.default_ticket_template = template
if self.category.is_root and not self.category.default_ticket_template:
raise Exception('Cannot clear default ticket template on root category')
return jsonify_data(html=_render_template_list(self.category))
def create_all_tables(db, verbose=False, add_initial_data=True):
"""Create all tables and required initial objects"""
from indico.modules.categories import Category
from indico.modules.designer import TemplateType
from indico.modules.designer.models.templates import DesignerTemplate
from indico.modules.oauth.models.applications import OAuthApplication, SystemAppType
from indico.modules.users import User
if verbose:
print(cformat('%{green}Creating tables'))
db.create_all()
if add_initial_data:
if verbose:
print(cformat('%{green}Creating system user'))
db.session.add(
User(id=0, is_system=True, first_name='Indico',
last_name='System'))
if verbose:
print(cformat('%{green}Creating root category'))
cat = Category(id=0,
title='Home',
protection_mode=ProtectionMode.public)
db.session.add(cat)
db.session.flush()
if verbose:
print(
cformat(
'%{green}Creating default ticket template for root category '
))
dt = DesignerTemplate(category_id=0,
title='Default ticket',
type=TemplateType.badge,
data=DEFAULT_TEMPLATE_DATA,
is_system_template=True)
cat.default_ticket_template = dt
db.session.add(dt)
if verbose:
print(cformat('%{green}Creating system oauth apps'))
for sat in SystemAppType:
if sat != SystemAppType.none:
db.session.add(
OAuthApplication(system_app_type=sat, **sat.default_data))
db.session.commit()
def _form_validated(self, form, **kwargs):
"""
Forbid to disable the tickets when access to CERN is requested and
to use CERN access ticket template with regforms without active CERN access request.
"""
if not isinstance(form, TicketsForm):
return
regform = RegistrationForm.get_or_404(request.view_args['reg_form_id'])
if regform.cern_access_request and regform.cern_access_request.is_active and not form.tickets_enabled.data:
err = _('This form is used to grant CERN site access so ticketing must be enabled')
form.tickets_enabled.errors.append(err)
return False
access_tpl = self.settings.get('access_ticket_template')
ticket_template = DesignerTemplate.get_or_404(form.ticket_template_id.data)
if not access_tpl:
return
if ticket_template == access_tpl or ticket_template.backside_template == access_tpl:
if (not regform.cern_access_request or
(regform.cern_access_request and
regform.cern_access_request.request_state != CERNAccessRequestState.active)):
form.ticket_template_id.errors.append(_('The selected template can only be used with an '
'active CERN access request'))
return False
def _process_args(self):
self.template = DesignerTemplate.get_or_404(request.view_args['template_id'])
def _checkParams(self, params):
RHRegistrationsActionBase._checkParams(self, params)
self.template = DesignerTemplate.get_one(
request.view_args['template_id'])
def _process_args(self):
RHRegistrationsActionBase._process_args(self)
self.template = DesignerTemplate.get_one(request.view_args['template_id'])
def to_python(value):
return DesignerTemplate.get(value)
def _process_args(self):
RHManageEventBase._process_args(self)
self.template = DesignerTemplate.get_one(request.view_args['template_id'])
def get_all_templates(obj):
"""Get all templates usable by an event/category"""
category = obj.category if isinstance(obj, Event) else obj
return set(DesignerTemplate.find_all(DesignerTemplate.category_id.in_(categ['id'] for categ in category.chain)))
def _process_args(self):
self.template = DesignerTemplate.get_one(request.view_args['template_id'])
def _process_args(self):
self.template = DesignerTemplate.get_or_404(
request.view_args['template_id'])
if self.target.is_deleted:
raise NotFound
def _process_args(self):
RHRegistrationsActionBase._process_args(self)
self.template = DesignerTemplate.get_one(request.view_args['template_id'])
def _checkParams(self, params):
RHManageEventBase._checkParams(self, params)
self.template = DesignerTemplate.get_one(
request.view_args['template_id'])
def _checkParams(self):
self.template = DesignerTemplate.get_one(
request.view_args['template_id'])
def _process_args(self):
RHManageEventBase._process_args(self)
self.template = DesignerTemplate.get_one(
request.view_args['template_id'])
def get_all_templates(obj):
"""Get all templates usable by an event/category"""
category = obj.category if isinstance(obj, Event) else obj
return set(DesignerTemplate.find_all(DesignerTemplate.category_id.in_(categ['id'] for categ in category.chain)))
