def __init__(self, invoice):
self.invoice = invoice
self.invoice_datetime = ConfigStore.parse_date(
self.invoice.invoice_date)
self.config = ConfigStore.get_configuration(when=self.invoice_datetime)
self.translation = Translations.load('locale',
locales=[self.invoice.language],
domain='pyinvoice')
self.ugettext = self.translation.ugettext
self.format = Format(locale=self.invoice.language)
def test_renders_prices_with_correct_currency(self):
assert_equals(u'1.024,00 €', self.generator.format_price(1024))
self.generator.invoice.currency = 'USD'
self.generator.format = Format(locale='en')
assert_equals('en', str(self.generator.format.locale))
assert_equals(u'$1,024.00', self.generator.format_price(1024))
def __new__(cls, component, name, env=None):
self = str.__new__(cls, name)
self.component = component
self.translations = component.translations[name]
self.format = Format(name)
self.locale = Locale(name)
self._env = env
return self
def _get_format():
lang = translation.get_language()
try:
locale = Locale(translation.to_locale(lang))
except UnknownLocaleError:
locale = Locale(
translation.to_locale(settings.BABEL_FALLBACK.get(lang, 'en-US')))
return Format(locale)
def __new__(cls, name, root, translations_dir, categories=[]):
self = str.__new__(cls, name)
self.format = Format(name)
self.timezone = timezone('Europe/Moscow')
self.root = getattr(root, name)
self._translations = get_translations(translations_dir, self,
categories)
return self
def _format_decimal(num, format=None):
"""Returns the string of a number formatted for the current language.
Uses django's translation.get_language() to find the current language from
the request.
Falls back to the default language if babel does not support the current.
"""
lang = translation.get_language()
if not localedata.exists(lang):
lang = settings.LANGUAGE_CODE
locale = Locale(translation.to_locale(lang))
return Format(locale).decimal(num, format)
def _get_format():
lang = get_language()
return Format(utils.get_locale_from_lang(lang))
def _get_format():
lang = translation.get_language()
locale = Locale(translation.to_locale(lang))
return Format(locale)
def _get_format():
lang = translation.get_language()
return Format(get_locale_from_lang(lang))
def __new__(cls, env, name):
self = str.__new__(cls, name)
self._env = weakproxy(env)
self.format = Format(name)
return self
class Lang(str):
def __new__(cls, env, name):
self = str.__new__(cls, name)
self._env = weakproxy(env)
self.format = Format(name)
return self
@cached_property
def root(self):
return getattr(self._env.root, self)
@cached_property
def url_for(self):
return self.root.build_url
@cached_property
def others(self):
return tuple(lang for lang in self._env.langs if lang!=self)
@cached_property
def _translations(self):
return self._env.get_translations(self)
def gettext(self, msgid):
message = self._translations.gettext(unicode(msgid))
if isinstance(msgid, Markup):
message = Markup(message)
return message
def ngettext(self, msgid1, msgid2, n):
message = self._translations.ngettext(unicode(msgid1),
unicode(msgid2), n)
if isinstance(msgid1, Markup):
message = Markup(message)
return message
def date(self, date, format=None):
return format_date(date, format, locale=self)
def datetime(self, datetime, format=None):
return format_datetime(datetime, format, locale=self)
def daterange(self, start, end):
return format_daterange(start, end, locale=self)
@cached_property
def date_formats(self):
return {'DATE': dates.DATE_FORMATS[self],
'DATETIME': dates.DATETIME_FORMATS[self],
'MONTH': dates.MONTH_FORMATS[self]}
def timedelta2(self, seconds, **kwargs):
for (i, (nm, tm)) in enumerate(TIMEDELTA_UNITS):
if tm < seconds:
result = format_timedelta(seconds, threshold=1, locale=self, **kwargs)
smaller_tm = seconds % tm
not_last = i < len(TIMEDELTA_UNITS) - 1
if not_last and smaller_tm > TIMEDELTA_UNITS[i+1][1]:
result += ' ' + self.format.timedelta(smaller_tm, threshold=1, **kwargs)
return result
return format_timedelta(seconds, locale=self, **kwargs)
class RMLGenerator(object):
def __init__(self, invoice):
self.invoice = invoice
self.invoice_datetime = ConfigStore.parse_date(
self.invoice.invoice_date)
self.config = ConfigStore.get_configuration(when=self.invoice_datetime)
self.translation = Translations.load('locale',
locales=[self.invoice.language],
domain='pyinvoice')
self.ugettext = self.translation.ugettext
self.format = Format(locale=self.invoice.language)
def build(self, output_dir, basename, should_embed_logo=False):
rml_string = self.render_template()
#self.save_rml_file(rml_string, output_dir, basename)
self.build_pdf(rml_string, output_dir, basename, should_embed_logo)
def render_template(self):
user_template = self.config['rml_template']
if os.path.isfile(user_template):
user_template = os.path.dirname(user_template)
def template_loaded(template):
Translator(self.translation).setup(template)
loader = TemplateLoader([user_template, this_dir],
callback=template_loaded)
template = loader.load('rg.rml')
stream = template.generate(**self.template_variables())
return stream.render('xhtml')
def build_pdf(self, rml_string, output_dir, basename, should_embed_logo):
filename = self.get_pdf_filename(output_dir, basename)
cur_dirname = os.path.dirname(__file__)
fontdir = os.path.abspath(os.path.join(cur_dirname, "fonts"))
register_fonts_for_language(self.invoice.language, fontdir)
pdf_logo_fp = rml_to_pdf(rml_string, embed_logo=should_embed_logo)
file_handle = file(filename, "wb")
file_handle.write(pdf_logo_fp.getvalue())
file_handle.close()
def save_rml_file(self, rml_string, output_dir, basename):
filename = self.get_rml_filename(output_dir, basename)
if isinstance(rml_string, unicode):
rml_string = rml_string.encode("UTF-8")
file_handle = file(filename, "w")
file_handle.write(rml_string)
file_handle.close()
def get_rml_filename(self, output_dir, basename):
filename = os.path.join(
output_dir, "%s.%s.rml" % (basename, self.invoice.language))
return filename
def get_pdf_filename(self, output_dir, basename):
filename = os.path.join(
output_dir, "%s.%s.pdf" % (basename, self.invoice.language))
return filename
def invoicing_party_variables(self):
return dict(
name=self.config["name"],
email=self.config["email"],
phone=self.config["tel"],
url=u"http://" + self.config["url"],
domain=self.config["url"],
bank=dict(
account_nr=self.config["bank_account_nr"],
code_nr=self.config["bank_code_nr"],
name=self.config["bank_name"],
iban=self.config["bank_iban"],
bic=self.config["bank_bic"],
),
paypal=self.config["paypal"],
ustidnr=self.config["ustidnr"],
taxnr=self.config['taxnr'],
address=dict(
street=self.config["street"],
zip=self.config["zip"],
city=self.config["city"],
),
)
def pdf_title(self):
title_template = self.ugettext(
"Rechnung Nr. %(number)s vom %(date)s: %(subject)s")
title_parameters = dict(number=self.invoice.invoice_number,
date=self.format.date(self.invoice_datetime),
subject=self.invoice.invoice_subject)
return title_template % title_parameters
def remove_latex_codes(self, text):
output = re.sub('\\\-', "", text)
return output
def text_transform(self, text):
output = text
output = re.sub('"(,|\.|\s+)', u"“\\1", output)
output = re.sub(u'(\s+)"', u'\\1„', output)
return output
def invoice_item_variables(self):
items = []
for i, item in enumerate(self.invoice.get_invoice_items()):
items.append(
dict(
position=i + 1,
description=self.text_transform(
self.remove_latex_codes(item.name)),
price=self.format_price(item.get_price(netto=True)),
))
return items
def template_variables(self):
vat_percentage = [0][0]
return dict(
title=self.pdf_title(),
author=self.config["name"],
invoicing_party=self.invoicing_party_variables(),
invoice=self.invoice,
invoice_date=self.format.date(self.invoice_datetime),
vat_percentage=self.format.percent(vat_percentage),
invoice_items=self.invoice_item_variables(),
vat_items=self.invoice.get_vat_sums(),
format=self.format,
format_price=self.format_price,
)
def format_price(self, price):
return self.format.currency(price, currency=self.invoice.currency)