def theme(request, id=None):
shop = request.shop
theme = shop.theme
edit = request.GET.get('edit', None)
if id is None:
template = Template.objects.filter(theme=theme, name='layout').get()
edit = 'template'
else:
if edit == 'template':
template = get_object_or_404(Template, pk=id)
if template.theme.shop != shop:
raise Http404
elif edit == 'asset':
asset = get_object_or_404(Asset, pk=id)
if asset.theme.shop != shop and asset.is_editable():
raise Http404
param = {}
if edit == 'template':
text = copy.copy(template.text)
form_template = TemplateForm(request.POST or None, instance=template)
if form_template.is_valid():
if text != form_template.cleaned_data['text']:
shop.last_date_to_change_layout = datetime.datetime.now()
shop.save()
form_template.save()
# request.flash['message'] = unicode(_("Template successfully saved."))
# request.flash['severity'] = "success"
return HttpResponse('Template successfully saved.')
#return HttpResponseRedirect(reverse('web_store_theme', args=[template.id])+"?edit=template")
version_list = Version.objects.get_for_object(template).order_by('-pk')[:10]
param = {'form_template': form_template,
'version_list': version_list,
'template': template}
else: # edit == 'asset'
try:
if request.method == 'POST':
form_asset = AssetEditForm(shop=shop, data=request.POST)
if form_asset.is_valid():
text = form_asset.cleaned_data['text']
if asset.file.storage.exists(asset.file.name):
asset.file.storage.delete(asset.file.name)
asset.file.save(asset.file.name, ContentFile(str(text)))
try:
shop.last_date_to_change_layout = datetime.datetime.now()
shop.save()
asset.save()
asset.render()
except Exception,e:
return HttpResponse(e)
return HttpResponse('File successfully saved.')
else:
errors = "\n".join(["%s" % (v.as_text()) for k,v in form_asset.errors.iteritems()])
return HttpResponse(errors)
else:
def edit_notebook(nb_id):
nb = NotebookTemplate.query.get_or_404(nb_id)
form = TemplateForm(obj=nb)
task_list = Task.query.order_by(Task.short).all()
form.tasks.choices = [(task.id, "[{}] {}".format(task.short, task.name))
for task in task_list]
selected_tasks = [task.id for task in nb.tasks]
if request.method == 'GET':
form.tasks.data = [task.id for task in nb.tasks]
for _ in form.order_options:
form.order_options.pop_entry()
for order_option in nb.options:
option_field = OrderOptionForm()
option_field.order_type = 'random' if order_option.random else 'fixed'
form.order_options.append_entry(option_field)
for (idx, subform) in enumerate(form.order_options):
subform.tasks_random.choices = [(task.id, task.name)
for task in task_list]
subform.tasks_fixed.choices = [(task.id, task.name)
for task in task_list]
if request.method == 'GET':
subform.tasks_random.data = [
task.id for task in nb.options[idx].tasks
] if nb.options[idx].random else None
subform.tasks_fixed.data = nb.options[idx].tasks[
0].id if not nb.options[idx].random else None
if form.validate_on_submit():
if form.name.data != nb.name and NotebookTemplate.query.filter_by(
name=form.name.data).first():
flash('A notebook with this name already exists.', 'danger')
else:
nb.name = form.name.data
selected_tasks = form.tasks.data
nb.tasks = Task.query.filter(Task.id.in_(selected_tasks)).all()
to_remove = len(nb.options) - len(form.order_options.entries)
if to_remove > 0:
nb.options = nb.options[:-to_remove]
for (idx, subform) in enumerate(form.order_options.entries):
is_random = subform.order_type.data == 'random'
option_tasks = subform.tasks_random.data if is_random else [
subform.tasks_fixed.data
]
if idx >= len(nb.options):
# new option
option = OrderOption(idx, is_random)
nb.options.append(option)
else:
option = nb.options[idx]
option.random = is_random
option.tasks = Task.query.filter(
Task.id.in_(option_tasks)).all()
db.session.commit()
flash('Saved changes', 'success')
return render_template('notebook.html',
form=form,
notebook=nb,
selected_tasks=selected_tasks,
action=url_for('nbg.edit_notebook', nb_id=nb_id))
def POST(self):
form = TemplateForm()
if not form.validates():
return render.mail_tpl(form)
f = open(settings.MAIL_FILE_TEMPLATE, 'wb')
pickle.dump(form.d.template, f)
f.close()
raise web.seeother('/mail/template')
def POST(self):
form = TemplateForm()
if not form.validates():
return render.mail_tpl(form)
f = open(settings.MAIL_FILE_TEMPLATE, 'wb')
pickle.dump(form.d.template, f)
f.close()
raise web.seeother('/mail/template')
def GET(self):
try:
f = open(settings.MAIL_FILE_TEMPLATE, 'rb')
tpl = pickle.load(f)
f.close()
except (IOError, pickle.PickleError):
tpl = settings.MAIL_DEFAULT_TEMPLATE
form = TemplateForm()
form.fill(template=tpl)
return render.mail_tpl(form)
def GET(self):
try:
f = open(settings.MAIL_FILE_TEMPLATE, 'rb')
tpl = pickle.load(f)
f.close()
except (IOError, pickle.PickleError):
tpl = settings.MAIL_DEFAULT_TEMPLATE
form = TemplateForm()
form.fill(template=tpl)
return render.mail_tpl(form)
def saiki_templates_edit():
"""Docstring."""
if only_check():
if request.method == 'POST':
template_form = TemplateForm()
template_form.validate_on_submit()
print(template_form)
if template_form.validate() is False:
flash('Please check that all the fields are valid!.',
'critical')
return check_and_render('saiki_templates_edit.html',
form=template_form)
else:
update_template(template_form)
flash('updated Config for Topic : ' +
template_form.template_name.data)
return redirect(url_for('saiki_templates'))
elif request.method == 'GET':
template = request.args.get('template')
if template != '' and template is not None:
template_data = get_saiki_template_single(template)
else:
template = ''
template_data = '{}'
template_form = TemplateForm(template_name=template,
template_data=template_data)
return check_and_render('saiki_templates_edit.html',
form=template_form,
template_data=template_data)
else:
return check_and_render('index.html')
def create_notebook():
form = TemplateForm()
task_list = Task.query.order_by(Task.short).all()
form.tasks.choices = [(task.id, "[{}] {}".format(task.short, task.name))
for task in task_list]
for subform in form.order_options:
subform.tasks_random.choices = [(task.id, task.name)
for task in task_list]
subform.tasks_fixed.choices = [(task.id, task.name)
for task in task_list]
if form.validate_on_submit():
if NotebookTemplate.query.filter_by(name=form.name.data).first():
flash('A notebook template with this name already exists',
'danger')
else:
notebook = NotebookTemplate(form.name.data)
for task_id in form.tasks.data:
notebook.tasks.append(Task.query.get(task_id))
db.session.add(notebook)
db.session.commit()
for idx, option in enumerate(form.order_options.entries):
order_option = OrderOption(idx,
option.order_type.data == 'random')
order_option.notebook = notebook.id
if order_option.random:
for task_id in option.tasks_random.data:
order_option.tasks.append(Task.query.get(task_id))
else:
order_option.tasks.append(
Task.query.get(option.tasks_fixed.data))
db.session.add(order_option)
db.session.commit()
flash('Template created', 'success')
return redirect(url_for('nbg.list_notebooks'))
if not form.tasks.data:
form.tasks.data = [task_list[0].id]
selected_tasks = [task_id for task_id in form.tasks.data]
return render_template('notebook.html',
form=form,
selected_tasks=selected_tasks,
action=url_for('nbg.create_notebook'))
def template_edit(request, id):
shop = request.shop
template = get_object_or_404(Template, pk=id)
if template.theme.shop != shop:
raise Http404
text = copy.copy(template.text)
form = TemplateForm(request.POST or None, instance=template)
if form.is_valid():
if text != form.cleaned_data['text']:
form.save()
request.flash['message'] = unicode(_("Template successfully edited."))
request.flash['severity'] = "success"
return HttpResponseRedirect(reverse('template_edit', args=[id]))
version_list = Version.objects.get_for_object(template).order_by('-pk')[:10]
return render_to_response('themes/template_edit.html',
{
'form': form,
'template': template,
'templates': shop.theme.template_set.all(),
'version_list': version_list,
},
RequestContext(request))
def template_edit(request, id):
shop = request.shop
template = get_object_or_404(Template, pk=id)
if template.theme.shop != shop:
raise Http404
text = copy.copy(template.text)
form = TemplateForm(request.POST or None, instance=template)
if form.is_valid():
if text != form.cleaned_data['text']:
shop.shop.last_date_to_change_layout = datetime.datetime.now()
shop.save()
form.save()
request.flash['message'] = unicode(_("Template successfully edited."))
request.flash['severity'] = "success"
return HttpResponseRedirect(reverse('template_edit', args=[id]))
version_list = Version.objects.get_for_object(template).order_by(
'-pk')[:10]
return render_to_response(
'themes/template_edit.html', {
'form': form,
'template': template,
'templates': shop.theme.template_set.all(),
'version_list': version_list,
}, RequestContext(request))
def send_email(request):
if request.method == 'POST':
form = EmailForm(request.POST)
if form.is_valid():
data = form.cleaned_data
try:
send_mail(
data['subject'],
data['content'],
'*****@*****.**',
['*****@*****.**'],
fail_silently=False,
)
except:
template_form = TemplateForm(request.POST)
return render(
request, 'email.html', {
'form': form,
'template_form': template_form,
'message': 'Failed to Send to the Recipient!'
})
return render(request, 'email_success.html',
{'email': data['email']})
raise Http404
def theme(request, id=None):
shop = request.shop
theme = shop.theme
edit = request.GET.get('edit', None)
if id is None:
template = Template.objects.filter(theme=theme, name='layout').get()
edit = 'template'
else:
if edit == 'template':
template = get_object_or_404(Template, pk=id)
if template.theme.shop != shop:
raise Http404
elif edit == 'asset':
asset = get_object_or_404(Asset, pk=id)
if asset.theme.shop != shop and asset.is_editable():
raise Http404
param = {}
if edit == 'template':
text = copy.copy(template.text)
form_template = TemplateForm(request.POST or None, instance=template)
if form_template.is_valid():
if text != form_template.cleaned_data['text']:
shop.last_date_to_change_layout = datetime.datetime.now()
shop.save()
form_template.save()
# request.flash['message'] = unicode(_("Template successfully saved."))
# request.flash['severity'] = "success"
return HttpResponse('Template successfully saved.')
#return HttpResponseRedirect(reverse('web_store_theme', args=[template.id])+"?edit=template")
version_list = Version.objects.get_for_object(template).order_by(
'-pk')[:10]
param = {
'form_template': form_template,
'version_list': version_list,
'template': template
}
else: # edit == 'asset'
try:
if request.method == 'POST':
form_asset = AssetEditForm(shop=shop, data=request.POST)
if form_asset.is_valid():
text = form_asset.cleaned_data['text']
if asset.file.storage.exists(asset.file.name):
asset.file.storage.delete(asset.file.name)
asset.file.save(asset.file.name, ContentFile(str(text)))
try:
shop.last_date_to_change_layout = datetime.datetime.now(
)
shop.save()
asset.save()
asset.render()
except Exception, e:
return HttpResponse(e)
return HttpResponse('File successfully saved.')
else:
errors = "\n".join([
"%s" % (v.as_text())
for k, v in form_asset.errors.iteritems()
])
return HttpResponse(errors)
else:
def create_form(self, resource=None, edit_form=False):
"""Return form with fields loaded from DB.
:param object resource: Optional template object
:param bool edit_form: Set if edit form
"""
form = TemplateForm(self.config_models, obj=resource)
if edit_form:
# select responsible contact
form.responsible.data = self.ContactsHelper.resource_contact_id(
resource.gdi_oid, self.ContactsHelper.ROLE_RESPONSIBLE)
# show that template file is present
if resource.type == 'jasper':
form.jasper_file.description = "JasperReports Report vorhanden"
if resource.uploaded_report:
# add download link for uploaded report
filename = os.path.basename(resource.uploaded_report)
form.jasper_file.description = (
'JasperReports Report vorhanden: '
'<a href="jasper/%s" target="_blank">%s</a>' %
(filename, filename))
elif resource.type == 'info':
form.info_file.description = "HTML Template vorhanden"
if resource.template_filename:
# add download link for uploaded info template
filename = os.path.basename(resource.template_filename)
form.info_file.description = (
'HTML Template vorhanden: '
'<a href="info/%s" target="_blank">%s</a>' %
(filename, filename))
elif resource.type == 'qgis':
form.qgis_file.description = "QGIS Drucklayout vorhanden"
if resource.uploaded_qpt:
# add download link for uploaded QPT
filename = os.path.basename(resource.uploaded_qpt)
form.qgis_file.description = (
'QGIS Drucklayout vorhanden: '
'<a href="qpt/%s" target="_blank">%s</a>' %
(filename, filename))
if resource.type == 'jasper':
# add data products for resource on edit
for ows_layer in resource.ows_layers:
form.data_products.append_entry({
'data_product_id':
ows_layer.gdi_oid,
'data_product_name':
ows_layer.name
})
# add data sets for resource on edit
for data_set in resource.data_sets:
form.datasets.append_entry({
'data_set_id':
data_set.gdi_oid,
'data_set_name':
data_set.data_set_name
})
# add permissions for resource on edit
roles = self.PermissionsHelper.resource_roles(resource.gdi_oid)
for role in roles:
form.permissions.append_entry({
'role_id': role.id,
'role_name': role.name,
'read': True
})
# load related resources from DB
session = self.session()
# get OWS layers
query = session.query(self.OWSLayer).order_by(self.OWSLayer.name)
# skip WMS root layers
root_layers = self.OWSHelper.ows_root_layers(session)
root_layer_ids = [l.gdi_oid for l in root_layers]
if root_layer_ids:
query = query.filter(~self.OWSLayer.gdi_oid.in_(root_layer_ids))
ows_layers = query.all()
# get data sets
query = session.query(self.DataSet) \
.order_by(self.DataSet.data_set_name) \
.distinct(
self.DataSet.gdi_oid_data_source, self.DataSet.data_set_name
)
data_sets = query.all()
session.close()
# set choices for responsible select field
form.responsible.choices = [(0, "")] + \
self.ContactsHelper.person_choices()
# set choices for data product select field
form.data_product.choices = [(0, "")] + [(d.gdi_oid, d.name)
for d in ows_layers]
# set choices for data set select field
form.data_set.choices = [(0, "")] + [(d.gdi_oid, d.data_set_name)
for d in data_sets]
# collect role ids from permissions subform
role_permission_ids = [
int(permission.data['role_id']) for permission in form.permissions
]
# set choices for role permission select field
# skip roles from permissions subform
roles = self.PermissionsHelper.roles()
form.role.choices = [(role.id, role.name) for role in roles
if role.id not in role_permission_ids]
return form
