def pootle_context(request):
"""Exposes settings to templates."""
#FIXME: maybe we should expose relevant settings only?
context = {
'settings': {
'TITLE': get_site_title(),
'DESCRIPTION': get_site_description(),
'CAN_REGISTER': settings.CAN_REGISTER,
'CAN_CONTACT': settings.CAN_CONTACT and settings.CONTACT_EMAIL,
'SCRIPT_NAME': settings.SCRIPT_NAME,
'POOTLE_VERSION': sver,
'CACHE_TIMEOUT': settings.CACHE_MIDDLEWARE_SECONDS,
'DEBUG': settings.DEBUG,
},
'custom': settings.CUSTOM_TEMPLATE_CONTEXT,
}
context.update({
'ALL_LANGUAGES': Language.live.cached(),
'ALL_PROJECTS': Project.objects.cached(),
})
context.update(_agreement_context(request))
return context
def process_request(self, request):
"""Calculate settings.BASEURL based on HTTP headers."""
domain = None
if 'HTTP_HOST' in request.META:
domain = request.get_host()
if 'SCRIPT_NAME' in request.META:
settings.SCRIPT_NAME = request.META['SCRIPT_NAME']
if domain is not None:
domain += request.META['SCRIPT_NAME']
if domain is not None:
if request.is_secure():
settings.BASE_URL = 'https://' + domain
else:
settings.BASE_URL = 'http://' + domain
#FIXME: DIRTY HACK ALERT: if this works then something is
# wrong with the universe.
#
# Poison sites cache using detected domain.
from django.contrib.sites import models as sites_models
from pootle_app.models.pootle_site import get_site_title
new_site = sites_models.Site(settings.SITE_ID, request.get_host(),
get_site_title())
sites_models.SITE_CACHE[settings.SITE_ID] = new_site
def process_request(self, request):
"""Calculate settings.BASEURL based on HTTP headers."""
domain = None
if "HTTP_HOST" in request.META:
domain = request.get_host()
if "SCRIPT_NAME" in request.META:
settings.SCRIPT_NAME = request.META["SCRIPT_NAME"]
if domain is not None:
domain += request.META["SCRIPT_NAME"]
if domain is not None:
if request.is_secure():
settings.BASE_URL = "https://" + domain
else:
settings.BASE_URL = "http://" + domain
# FIXME: DIRTY HACK ALERT: if this works then something is
# wrong with the universe.
#
# Poison sites cache using detected domain.
from django.contrib.sites import models as sites_models
from pootle_app.models.pootle_site import get_site_title
new_site = sites_models.Site(settings.SITE_ID, request.get_host(), get_site_title())
sites_models.SITE_CACHE[settings.SITE_ID] = new_site
def pootle_context(request):
"""Exposes settings to templates."""
#FIXME: maybe we should expose relevant settings only?
context = {
'settings': {
'TITLE': get_site_title(),
'DESCRIPTION': get_site_description(),
'CAN_REGISTER': settings.CAN_REGISTER,
'CAN_CONTACT': settings.CAN_CONTACT and settings.CONTACT_EMAIL,
'SCRIPT_NAME': settings.SCRIPT_NAME,
'POOTLE_VERSION': sver,
'CACHE_TIMEOUT': settings.CACHE_MIDDLEWARE_SECONDS,
'DEBUG': settings.DEBUG,
},
'custom': settings.CUSTOM_TEMPLATE_CONTEXT,
}
context.update({
'ALL_LANGUAGES': Language.live.cached(),
'ALL_PROJECTS': Project.objects.cached(),
})
context.update(_agreement_context(request))
return context
def update_against_templates(self, pootle_path=None):
"""Update translation project from templates."""
if self.is_template_project:
return
template_translation_project = self.project \
.get_template_translationproject()
if (template_translation_project is None or
template_translation_project == self):
return
monolingual = self.project.is_monolingual
if not monolingual:
self.sync()
from pootle_app.project_tree import (convert_template,
get_translated_name,
get_translated_name_gnu)
for store in template_translation_project.stores.iterator():
if self.file_style == 'gnu':
new_pootle_path, new_path = get_translated_name_gnu(self, store)
else:
new_pootle_path, new_path = get_translated_name(self, store)
if pootle_path is not None and new_pootle_path != pootle_path:
continue
convert_template(self, store, new_pootle_path, new_path,
monolingual)
all_files, new_files = self.scan_files(vcs_sync=False)
project_path = self.project.get_real_path()
if new_files and versioncontrol.hasversioning(project_path):
message = ("New files added from %s based on templates" %
get_site_title())
filestocommit = [f.file.name for f in new_files]
success = True
try:
output = versioncontrol.add_files(project_path, filestocommit,
message)
except Exception:
logging.exception(u"Failed to add files")
success = False
if pootle_path is None:
from pootle_app.signals import post_template_update
post_template_update.send(sender=self)
def commit_file(self, user, store, request=None):
"""Commits an individual file to version control.
This does not do permission checking.
"""
from pootle_app.signals import post_vc_commit
store.sync(update_structure=False, update_translation=True,
conservative=True)
total = store.get_total_wordcount()
translated = store.get_translated_wordcount()
fuzzy = store.get_fuzzy_wordcount()
author = user.username
message = stats_message_raw("Commit from %s by user %s." % \
(get_site_title(), author), total, translated, fuzzy)
# Try to append email as well, since some VCS does not allow omitting
# it (ie. Git).
if user.is_authenticated() and len(user.email):
author += " <%s>" % user.email
filestocommit = [store.file.name]
success = True
for file in filestocommit:
try:
versioncontrol.commit_file(file, message=message,
author=author)
# FIXME: This belongs to views
if request is not None:
msg = _("Committed file <em>%(filename)s</em> to version "
"control", {'filename': file})
messages.success(request, msg)
except Exception as e:
logging.exception(u"Failed to commit file")
# FIXME: This belongs to views
if request is not None:
msg_params = {
"filename": file,
"error": e,
}
msg = _("Failed to commit <em>%(filename)s</em> to version "
"control: %(error)s", msg_params)
messages.error(request, msg)
success = False
post_vc_commit.send(sender=self, path_obj=store,
user=user, success=success)
return success
def commit_dir(self, user, directory, request=None):
"""Commits files under a directory to version control.
This does not do permission checking.
"""
self.sync()
total = directory.get_total_wordcount()
translated = directory.get_translated_wordcount()
fuzzy = directory.get_fuzzy_wordcount()
author = user.username
message = stats_message_raw("Commit from %s by user %s." %
(get_site_title(), author),
total, translated, fuzzy)
# Try to append email as well, since some VCS does not allow omitting
# it (ie. Git).
if user.is_authenticated() and len(user.email):
author += " <%s>" % user.email
if directory.is_translationproject():
stores = list(self.stores.exclude(file=""))
else:
stores = list(directory.stores.exclude(file=""))
filestocommit = [store.file.name for store in stores]
success = True
try:
project_path = self.project.get_real_path()
versioncontrol.add_files(project_path, filestocommit, message,
author)
# FIXME: This belongs to views
if request is not None:
msg = _("Committed all files under <em>%(path)s</em> to "
"version control", {'path': directory.pootle_path})
messages.success(request, msg)
except Exception as e:
logging.exception(u"Failed to commit directory")
# FIXME: This belongs to views
if request is not None:
msg = _("Failed to commit to version control: %(error)s",
{'error': e})
messages.error(request, msg)
success = False
from pootle_app.signals import post_vc_commit
post_vc_commit.send(sender=self, path_obj=directory,
user=user, success=success)
return success
def commit_file(self, user, store, request=None):
"""Commits an individual file to version control.
This does not do permission checking.
"""
store.sync(update_structure=False, update_translation=True,
conservative=True)
total = store.get_total_wordcount()
translated = store.get_translated_wordcount()
fuzzy = store.get_fuzzy_wordcount()
author = user.username
message = stats_message_raw("Commit from %s by user %s." % \
(get_site_title(), author), total, translated, fuzzy)
# Try to append email as well, since some VCS does not allow omitting
# it (ie. Git).
if user.is_authenticated() and len(user.email):
author += " <%s>" % user.email
from pootle.scripts import hooks
try:
filestocommit = hooks.hook(self.project.code, "precommit",
store.file.name, author=author,
message=message)
except ImportError:
# Failed to import the hook - we're going to assume there just
# isn't a hook to import. That means we'll commit the original
# file.
filestocommit = [store.file.name]
success = True
try:
from pootle_misc import versioncontrol
for file in filestocommit:
versioncontrol.commit_file(file, message=message,
author=author)
# FIXME: This belongs to views
if request is not None:
msg = _("Committed file <em>%(filename)s</em> to version "
"control", {'filename': file})
messages.success(request, msg)
except Exception as e:
logging.exception(u"Failed to commit file")
# FIXME: This belongs to views
if request is not None:
msg_params = {
'filename': filename,
'error': e,
}
msg = _("Failed to commit <em>%(filename)s</em> to version "
"control: %(error)s", msg_params)
messages.error(request, msg)
success = False
try:
hooks.hook(self.project.code, "postcommit", store.file.name,
success=success)
except:
#FIXME: We should not hide the exception - makes development
# impossible
pass
from pootle_app.models.signals import post_vc_commit
post_vc_commit.send(sender=self, path_obj=store,
user=user, success=success)
return success
def commit_dir(self, user, directory, request=None):
"""Commits files under a directory to version control.
This does not do permission checking.
"""
self.sync()
total = directory.get_total_wordcount()
translated = directory.get_translated_wordcount()
fuzzy = directory.get_fuzzy_wordcount()
author = user.username
message = stats_message_raw("Commit from %s by user %s." %
(get_site_title(), author),
total, translated, fuzzy)
# Try to append email as well, since some VCS does not allow omitting
# it (ie. Git).
if user.is_authenticated() and len(user.email):
author += " <%s>" % user.email
if directory.is_translationproject():
stores = list(self.stores.exclude(file=""))
else:
stores = list(directory.stores.exclude(file=""))
filestocommit = []
from pootle.scripts import hooks
for store in stores:
try:
filestocommit.extend(hooks.hook(self.project.code, "precommit",
store.file.name, author=author,
message=message)
)
except ImportError:
# Failed to import the hook - we're going to assume there just
# isn't a hook to import. That means we'll commit the original
# file.
filestocommit.append(store.file.name)
success = True
try:
from pootle_misc import versioncontrol
project_path = self.project.get_real_path()
versioncontrol.add_files(project_path, filestocommit, message,
author)
# FIXME: This belongs to views
if request is not None:
msg = _("Committed all files under <em>%(path)s</em> to "
"version control", {'path': directory.pootle_path})
messages.success(request, msg)
except Exception as e:
logging.exception(u"Failed to commit directory")
# FIXME: This belongs to views
if request is not None:
msg = _("Failed to commit to version control: %(error)s",
{'error': e})
messages.error(request, msg)
success = False
for store in stores:
try:
hooks.hook(self.project.code, "postcommit", store.file.name,
success=success)
except:
#FIXME: We should not hide the exception - makes development
# impossible
pass
from pootle_app.models.signals import post_vc_commit
post_vc_commit.send(sender=self, path_obj=directory,
user=user, success=success)
return success
def update_against_templates(self, pootle_path=None):
"""Update translation project from templates."""
if self.is_template_project:
return
template_translation_project = self.project \
.get_template_translationproject()
if (template_translation_project is None or
template_translation_project == self):
return
monolingual = self.project.is_monolingual
if not monolingual:
self.sync()
from pootle_app.project_tree import (convert_template,
get_translated_name,
get_translated_name_gnu)
for store in template_translation_project.stores.iterator():
if self.file_style == 'gnu':
new_pootle_path, new_path = get_translated_name_gnu(self, store)
else:
new_pootle_path, new_path = get_translated_name(self, store)
if pootle_path is not None and new_pootle_path != pootle_path:
continue
try:
from pootle.scripts import hooks
relative_po_path = os.path.relpath(new_path,
settings.PODIRECTORY)
if not hooks.hook(self.project.code, "pretemplateupdate",
relative_po_path):
continue
except:
# Assume hook is not present.
pass
convert_template(self, store, new_pootle_path, new_path,
monolingual)
all_files, new_files = self.scan_files(vcs_sync=False)
from pootle_misc import versioncontrol
project_path = self.project.get_real_path()
if new_files and versioncontrol.hasversioning(project_path):
from pootle.scripts import hooks
message = ("New files added from %s based on templates" %
get_site_title())
filestocommit = []
for new_file in new_files:
try:
hook_files = hooks.hook(self.project.code, "precommit",
new_file.file.name, author=None,
message=message)
filestocommit.extend(hook_files)
except ImportError:
# Failed to import the hook - we're going to assume there
# just isn't a hook to import. That means we'll commit the
# original file.
filestocommit.append(new_file.file.name)
success = True
try:
output = versioncontrol.add_files(project_path, filestocommit,
message)
except Exception:
logging.exception(u"Failed to add files")
success = False
for new_file in new_files:
try:
hooks.hook(self.project.code, "postcommit",
new_file.file.name, success=success)
except:
#FIXME: We should not hide the exception - makes
# development impossible
pass
if pootle_path is None:
from pootle_app.models.signals import post_template_update
post_template_update.send(sender=self)
def commit_file(self, user, store, request=None):
"""Commits an individual file to version control.
This does not do permission checking.
"""
store.sync(update_structure=False,
update_translation=True,
conservative=True)
total = store.get_total_wordcount()
translated = store.get_translated_wordcount()
fuzzy = store.get_fuzzy_wordcount()
author = user.username
message = stats_message_raw("Commit from %s by user %s." % \
(get_site_title(), author), total, translated, fuzzy)
# Try to append email as well, since some VCS does not allow omitting
# it (ie. Git).
if user.is_authenticated() and len(user.email):
author += " <%s>" % user.email
from pootle.scripts import hooks
try:
filestocommit = hooks.hook(self.project.code,
"precommit",
store.file.name,
author=author,
message=message)
except ImportError:
# Failed to import the hook - we're going to assume there just
# isn't a hook to import. That means we'll commit the original
# file.
filestocommit = [store.file.name]
success = True
try:
from pootle_misc import versioncontrol
for file in filestocommit:
versioncontrol.commit_file(file,
message=message,
author=author)
# FIXME: This belongs to views
if request is not None:
msg = _(
"Committed file <em>%(filename)s</em> to version "
"control", {'filename': file})
messages.success(request, msg)
except Exception as e:
logging.exception(u"Failed to commit file")
# FIXME: This belongs to views
if request is not None:
msg_params = {
'filename': filename,
'error': e,
}
msg = _(
"Failed to commit <em>%(filename)s</em> to version "
"control: %(error)s", msg_params)
messages.error(request, msg)
success = False
try:
hooks.hook(self.project.code,
"postcommit",
store.file.name,
success=success)
except:
#FIXME: We should not hide the exception - makes development
# impossible
pass
from pootle_app.models.signals import post_vc_commit
post_vc_commit.send(sender=self,
path_obj=store,
user=user,
success=success)
return success
def commit_dir(self, user, directory, request=None):
"""Commits files under a directory to version control.
This does not do permission checking.
"""
self.sync()
total = directory.get_total_wordcount()
translated = directory.get_translated_wordcount()
fuzzy = directory.get_fuzzy_wordcount()
author = user.username
message = stats_message_raw(
"Commit from %s by user %s." % (get_site_title(), author), total,
translated, fuzzy)
# Try to append email as well, since some VCS does not allow omitting
# it (ie. Git).
if user.is_authenticated() and len(user.email):
author += " <%s>" % user.email
if directory.is_translationproject():
stores = list(self.stores.exclude(file=""))
else:
stores = list(directory.stores.exclude(file=""))
filestocommit = []
from pootle.scripts import hooks
for store in stores:
try:
filestocommit.extend(
hooks.hook(self.project.code,
"precommit",
store.file.name,
author=author,
message=message))
except ImportError:
# Failed to import the hook - we're going to assume there just
# isn't a hook to import. That means we'll commit the original
# file.
filestocommit.append(store.file.name)
success = True
try:
from pootle_misc import versioncontrol
project_path = self.project.get_real_path()
versioncontrol.add_files(project_path, filestocommit, message,
author)
# FIXME: This belongs to views
if request is not None:
msg = _(
"Committed all files under <em>%(path)s</em> to "
"version control", {'path': directory.pootle_path})
messages.success(request, msg)
except Exception as e:
logging.exception(u"Failed to commit directory")
# FIXME: This belongs to views
if request is not None:
msg = _("Failed to commit to version control: %(error)s",
{'error': e})
messages.error(request, msg)
success = False
for store in stores:
try:
hooks.hook(self.project.code,
"postcommit",
store.file.name,
success=success)
except:
#FIXME: We should not hide the exception - makes development
# impossible
pass
from pootle_app.models.signals import post_vc_commit
post_vc_commit.send(sender=self,
path_obj=directory,
user=user,
success=success)
return success
def update_against_templates(self, pootle_path=None):
"""Update translation project from templates."""
if self.is_template_project:
return
template_translation_project = self.project \
.get_template_translationproject()
if (template_translation_project is None
or template_translation_project == self):
return
monolingual = self.project.is_monolingual
if not monolingual:
self.sync()
from pootle_app.project_tree import (convert_template,
get_translated_name,
get_translated_name_gnu)
for store in template_translation_project.stores.iterator():
if self.file_style == 'gnu':
new_pootle_path, new_path = get_translated_name_gnu(
self, store)
else:
new_pootle_path, new_path = get_translated_name(self, store)
if pootle_path is not None and new_pootle_path != pootle_path:
continue
try:
from pootle.scripts import hooks
relative_po_path = os.path.relpath(new_path,
settings.PODIRECTORY)
if not hooks.hook(self.project.code, "pretemplateupdate",
relative_po_path):
continue
except:
# Assume hook is not present.
pass
convert_template(self, store, new_pootle_path, new_path,
monolingual)
all_files, new_files = self.scan_files(vcs_sync=False)
from pootle_misc import versioncontrol
project_path = self.project.get_real_path()
if new_files and versioncontrol.hasversioning(project_path):
from pootle.scripts import hooks
message = ("New files added from %s based on templates" %
get_site_title())
filestocommit = []
for new_file in new_files:
try:
hook_files = hooks.hook(self.project.code,
"precommit",
new_file.file.name,
author=None,
message=message)
filestocommit.extend(hook_files)
except ImportError:
# Failed to import the hook - we're going to assume there
# just isn't a hook to import. That means we'll commit the
# original file.
filestocommit.append(new_file.file.name)
success = True
try:
output = versioncontrol.add_files(project_path, filestocommit,
message)
except Exception:
logging.exception(u"Failed to add files")
success = False
for new_file in new_files:
try:
hooks.hook(self.project.code,
"postcommit",
new_file.file.name,
success=success)
except:
#FIXME: We should not hide the exception - makes
# development impossible
pass
if pootle_path is None:
from pootle_app.models.signals import post_template_update
post_template_update.send(sender=self)
