from django.conf import settings
from django.core.files.base import ContentFile
from pretix.base.models import CachedFile, Event, cachedfile_name
from pretix.base.signals import register_data_exporters
def export(event, fileid, provider, form_data):
event = Event.objects.current.get(identity=event)
file = CachedFile.objects.get(id=fileid)
responses = register_data_exporters.send(event)
for receiver, response in responses:
ex = response(event)
if ex.identifier == provider:
file.filename, file.type, data = ex.render(form_data)
file.file.save(cachedfile_name(file, file.filename), ContentFile(data))
file.save()
if settings.HAS_CELERY:
from pretix.celery import app
export_task = app.task(export)
export = lambda *args, **kwargs: export_task.apply_async(args=args, kwargs=kwargs)
from pretix.base.models import CachedFile, CachedTicket, Order, cachedfile_name
from pretix.base.signals import register_ticket_outputs
def generate(order, provider):
order = Order.objects.current.select_related('event').get(identity=order)
ct = CachedTicket.objects.get_or_create(order=order, provider=provider)[0]
if not ct.cachedfile:
cf = CachedFile()
cf.date = now()
cf.expires = order.event.date_from + timedelta(days=30)
cf.save()
ct.cachedfile = cf
ct.save()
responses = register_ticket_outputs.send(order.event)
for receiver, response in responses:
prov = response(order.event)
if prov.identifier == provider:
ct.cachedfile.filename, ct.cachedfile.type, data = prov.generate(order)
ct.cachedfile.file.save(cachedfile_name(ct.cachedfile, ct.cachedfile.filename), ContentFile(data))
ct.cachedfile.save()
if settings.HAS_CELERY:
from pretix.celery import app
generate_task = app.task(generate)
generate = lambda *args, **kwargs: generate_task.apply_async(args=args, kwargs=kwargs)
from django.conf import settings
from django.core.files.base import ContentFile
from typing import Any, Dict
from pretix.base.models import CachedFile, Event, cachedfile_name
from pretix.base.signals import register_data_exporters
def export(event: str, fileid: str, provider: str,
form_data: Dict[str, Any]) -> None:
event = Event.objects.get(id=event)
file = CachedFile.objects.get(id=fileid)
responses = register_data_exporters.send(event)
for receiver, response in responses:
ex = response(event)
if ex.identifier == provider:
file.filename, file.type, data = ex.render(form_data)
file.file.save(cachedfile_name(file, file.filename),
ContentFile(data))
file.save()
if settings.HAS_CELERY:
from pretix.celery import app
export_task = app.task(export)
def export(*args, **kwargs):
export_task.apply_async(args=args, kwargs=kwargs)
event.id if event else None)
def mail_send(to: str,
subject: str,
body: str,
sender: str,
event: int = None) -> bool:
email = EmailMessage(subject, body, sender, to=to)
if event:
event = Event.objects.get(id=event)
backend = event.get_mail_backend()
else:
backend = get_connection(fail_silently=False)
try:
backend.send_messages([email])
return True
except Exception:
logger.exception('Error sending e-mail')
return False
if settings.HAS_CELERY and settings.EMAIL_BACKEND != 'django.core.mail.outbox':
from pretix.celery import app
mail_send_task = app.task(mail_send)
def mail_send(*args, **kwargs):
mail_send_task.apply_async(args=args, kwargs=kwargs)
colwidths = [a * doc.width for a in (.45, .10, .15, .15, .15)]
table = Table(tdata, colWidths=colwidths, repeatRows=2)
table.setStyle(TableStyle(tstyledata))
story.append(table)
doc.build(story)
return doc
def invoice_pdf(invoice: int):
i = Invoice.objects.get(pk=invoice)
with language(i.locale):
with tempfile.NamedTemporaryFile(suffix=".pdf") as f:
_invoice_generate_german(i, f)
f.seek(0)
i.file.save('invoice.pdf', ContentFile(f.read()))
i.save()
return i.file.name
if settings.HAS_CELERY:
from pretix.celery import app
invoice_pdf_task = app.task(invoice_pdf)
def invoice_pdf(*args, **kwargs):
# We introduce a 2 second delay, because otherwise we run into conditions where
# the task worker tries to generate the PDF even before our database transaction
# was committed and therefore fails to find the invoice object.
invoice_pdf_task.apply_async(args=args, kwargs=kwargs, countdown=2)
sassdir = os.path.join(settings.STATIC_ROOT, 'pretixpresale/scss')
sassrules = [
'$brand-primary: {};'.format(event.settings.get('primary_color')),
'@import "main.scss";',
]
css = sass.compile(
string="\n".join(sassrules),
include_paths=[sassdir], output_style='compressed',
custom_functions=django_libsass.CUSTOM_FUNCTIONS
)
checksum = hashlib.sha1(css.encode('utf-8')).hexdigest()
fname = '{}/{}/presale.{}.css'.format(
event.organizer.slug, event.slug, checksum[:16]
)
if event.settings.get('presale_css_checksum', '') != checksum:
newname = default_storage.save(fname, ContentFile(css))
event.settings.set('presale_css_file', newname)
event.settings.set('presale_css_checksum', checksum)
if settings.HAS_CELERY:
from pretix.celery import app
regenerate_css_task = app.task(regenerate_css)
def regenerate_css(*args, **kwargs):
regenerate_css_task.apply_async(args=args, kwargs=kwargs)
if prefix:
subject = "[%s] %s" % (prefix, subject)
body += "\r\n\r\n----\r\n"
body += _(
"You are receiving this e-mail because you placed an order for %s." % event.name
)
body += "\r\n"
try:
return mail_send([email], subject, body, sender)
finally:
translation.activate(_lng)
def mail_send(to, subject, body, sender):
email = EmailMessage(subject, body, sender, to=to)
try:
email.send(fail_silently=False)
return True
except Exception:
logger.exception('Error sending e-mail')
return False
if settings.HAS_CELERY and settings.EMAIL_BACKEND != 'django.core.mail.outbox':
from pretix.celery import app
mail_send_task = app.task(mail_send)
mail_send = lambda *args, **kwargs: mail_send_task.apply_async(args=args, kwargs=kwargs)
def generate(order: str, provider: str):
order = Order.objects.select_related('event').get(id=order)
ct = CachedTicket.objects.get_or_create(order=order, provider=provider)[0]
if not ct.cachedfile:
cf = CachedFile()
cf.date = now()
cf.expires = order.event.date_from + timedelta(days=30)
cf.save()
ct.cachedfile = cf
ct.save()
responses = register_ticket_outputs.send(order.event)
for receiver, response in responses:
prov = response(order.event)
if prov.identifier == provider:
ct.cachedfile.filename, ct.cachedfile.type, data = prov.generate(
order)
ct.cachedfile.file.save(
cachedfile_name(ct.cachedfile, ct.cachedfile.filename),
ContentFile(data))
ct.cachedfile.save()
if settings.HAS_CELERY:
from pretix.celery import app
generate_task = app.task(generate)
generate = lambda *args, **kwargs: generate_task.apply_async(args=args,
kwargs=kwargs)
colwidths = [a * doc.width for a in (.45, .10, .15, .15, .15)]
table = Table(tdata, colWidths=colwidths, repeatRows=2)
table.setStyle(TableStyle(tstyledata))
story.append(table)
doc.build(story)
return doc
def invoice_pdf(invoice: int):
i = Invoice.objects.get(pk=invoice)
with language(i.locale):
with tempfile.NamedTemporaryFile(suffix=".pdf") as f:
_invoice_generate_german(i, f)
f.seek(0)
i.file.save('invoice.pdf', ContentFile(f.read()))
i.save()
return i.file.name
if settings.HAS_CELERY:
from pretix.celery import app
invoice_pdf_task = app.task(invoice_pdf)
def invoice_pdf(*args, **kwargs):
# We introduce a 2 second delay, because otherwise we run into conditions where
# the task worker tries to generate the PDF even before our database transaction
# was committed and therefore fails to find the invoice object.
invoice_pdf_task.apply_async(args=args, kwargs=kwargs, countdown=2)
