def evernote_login(request, create=0):
redirect_to = request.REQUEST.get(auth.REDIRECT_FIELD_NAME, '')
language = request.REQUEST.get('language')
request.session['django_language'] = language
script_name = (settings.SCRIPT_NAME and "%s/" %
settings.SCRIPT_NAME.rstrip('/').lstrip('/') or '')
server_alias = settings.EVERNOTE_LOGIN_REDIRECT_SERVER_ALIAS
if not request.user.is_authenticated():
if create:
return sso_return_view(request, redirect_to, create)
else:
return redirect(
settings.EVERNOTE_LOGIN_URL +
'%s/%saccounts/evernote/return/%s' %
(server_alias, script_name, redirect_to.lstrip('/'))
)
else:
if not hasattr(request.user, 'evernote_account'):
return redirect(
settings.EVERNOTE_LOGIN_URL +
'%s/%saccounts/evernote/create/return/%s' %
(server_alias, script_name, redirect_to.lstrip('/'))
)
else:
return redirect_after_login(request, redirect_to)
def export_as_type(request, store, filetype):
"""Export given file to xliff for offline translation."""
from pootle_store.filetypes import factory_classes, is_monolingual
klass = factory_classes.get(filetype, None)
if (not klass or is_monolingual(klass) or
store.pootle_path.endswith(filetype)):
raise ValueError
path, ext = os.path.splitext(store.real_path)
export_path = os.path.join('POOTLE_EXPORT',
path + os.path.extsep + filetype)
abs_export_path = absolute_real_path(export_path)
key = iri_to_uri("%s:export_as_%s" % (store.pootle_path, filetype))
last_export = cache.get(key)
if (not (last_export and last_export == store.get_mtime() and
os.path.isfile(abs_export_path))):
from pootle_app.project_tree import ensure_target_dir_exists
from pootle_misc import ptempfile as tempfile
import shutil
ensure_target_dir_exists(abs_export_path)
outputstore = store.convert(klass)
fd, tempstore = tempfile.mkstemp(prefix=store.name,
suffix=os.path.extsep + filetype)
os.close(fd)
outputstore.savefile(tempstore)
shutil.move(tempstore, abs_export_path)
cache.set(key, store.get_mtime(), settings.OBJECT_CACHE_TIMEOUT)
return redirect('/export/' + export_path)
def export_as_type(request, pootle_path, filetype):
"""export given file to xliff for offline translation"""
if pootle_path[0] != '/':
pootle_path = '/' + pootle_path
store = get_object_or_404(Store, pootle_path=pootle_path)
klass = factory_classes.get(filetype, None)
if not klass or is_monolingual(klass) or \
pootle_path.endswith(filetype):
raise ValueError
path, ext = os.path.splitext(store.real_path)
export_path = os.path.join(
'POOTLE_EXPORT', path + os.path.extsep + filetype)
abs_export_path = absolute_real_path(export_path)
key = iri_to_uri("%s:export_as_%s" % (pootle_path, filetype))
last_export = cache.get(key)
if not (last_export and last_export == store.get_mtime() and
os.path.isfile(abs_export_path)):
ensure_target_dir_exists(abs_export_path)
outputstore = store.convert(klass)
file_desc, tempstore = tempfile.mkstemp(
prefix=store.name, suffix=os.path.extsep + filetype)
os.close(file_desc)
outputstore.savefile(tempstore)
shutil.move(tempstore, abs_export_path)
cache.set(key, store.get_mtime(), settings.OBJECT_CACHE_TIMEOUT)
return redirect('/export/' + export_path)
def evernote_account_disconnect(request):
if hasattr(request.user, 'evernote_account'):
ea = request.user.evernote_account
if not ea.user_autocreated:
ea.delete()
return redirect('/accounts/evernote/link/')
def export_as_xliff(request, store):
"""Export given file to xliff for offline translation."""
path = store.real_path
if not path:
# bug 2106
project = request.translation_project.project
if project.get_treestyle() == "gnu":
path = "/".join(store.pootle_path.split(os.path.sep)[2:])
else:
parts = store.pootle_path.split(os.path.sep)[1:]
path = "%s/%s/%s" % (parts[1], parts[0], "/".join(parts[2:]))
path, ext = os.path.splitext(path)
export_path = "/".join(['POOTLE_EXPORT', path + os.path.extsep + 'xlf'])
abs_export_path = absolute_real_path(export_path)
key = iri_to_uri("%s:export_as_xliff" % store.pootle_path)
last_export = cache.get(key)
if (not (last_export and last_export == store.get_mtime() and
os.path.isfile(abs_export_path))):
from pootle_app.project_tree import ensure_target_dir_exists
from translate.storage.poxliff import PoXliffFile
from pootle_misc import ptempfile as tempfile
import shutil
ensure_target_dir_exists(abs_export_path)
outputstore = store.convert(PoXliffFile)
outputstore.switchfile(store.name, createifmissing=True)
fd, tempstore = tempfile.mkstemp(prefix=store.name, suffix='.xlf')
os.close(fd)
outputstore.savefile(tempstore)
shutil.move(tempstore, abs_export_path)
cache.set(key, store.get_mtime(), settings.OBJECT_CACHE_TIMEOUT)
return redirect('/export/' + export_path)
def export_zip(request, translation_project, file_path):
if not check_permission("archive", request):
raise PermissionDenied(_('You do not have the right to create ZIP archives.'))
translation_project.sync()
pootle_path = translation_project.pootle_path + (file_path or '')
archivename = '%s-%s' % (translation_project.project.code, translation_project.language.code)
if file_path.endswith('/'):
file_path = file_path[:-1]
if file_path:
archivename += '-' + file_path.replace('/', '-')
archivename += '.zip'
export_path = os.path.join('POOTLE_EXPORT', translation_project.real_path, archivename)
abs_export_path = absolute_real_path(export_path)
key = "%s:export_zip" % pootle_path
last_export = cache.get(key)
if not (last_export and last_export == translation_project.get_mtime() and os.path.isfile(abs_export_path)):
ensure_target_dir_exists(abs_export_path)
stores = Store.objects.filter(pootle_path__startswith=pootle_path).exclude(file='')
translation_project.get_archive(stores, abs_export_path)
cache.set(key, translation_project.get_mtime(), settings.OBJECT_CACHE_TIMEOUT)
return redirect('/export/' + export_path)
def display_page(request, virtual_path):
"""Displays an active page defined in `virtual_path`."""
page = None
for page_model in AbstractPage.__subclasses__():
try:
page = page_model.objects.live(request.user).get(
virtual_path=virtual_path, )
except ObjectDoesNotExist:
pass
if page is None:
raise Http404
if page.url:
return redirect(page.url)
if request.user.is_superuser and not page.active:
msg = _(
'This page is inactive and visible to administrators '
'only. You can activate it by <a href="%s">editing its '
'properties</a>', page.get_edit_url())
messages.warning(request, msg)
template_name = 'staticpages/page_display.html'
if request.is_ajax():
template_name = 'staticpages/_body.html'
ctx = {
'page': page,
}
return render_to_response(template_name, ctx, RequestContext(request))
def export_zip(request, translation_project, file_path):
translation_project.sync()
pootle_path = translation_project.pootle_path + (file_path or '')
archivename = '%s-%s' % (translation_project.project.code,
translation_project.language.code)
if file_path.endswith('/'):
file_path = file_path[:-1]
if file_path:
archivename += '-' + file_path.replace('/', '-')
archivename += '.zip'
export_path = os.path.join('POOTLE_EXPORT', translation_project.real_path,
archivename)
abs_export_path = absolute_real_path(export_path)
key = iri_to_uri("%s:export_zip" % pootle_path)
last_export = cache.get(key)
if (not (last_export and last_export == translation_project.get_mtime() and
os.path.isfile(abs_export_path))):
ensure_target_dir_exists(abs_export_path)
stores = Store.objects.filter(pootle_path__startswith=pootle_path) \
.exclude(file='')
translation_project.get_archive(stores, abs_export_path)
cache.set(key, translation_project.get_mtime(),
settings.OBJECT_CACHE_TIMEOUT)
return redirect('/export/' + export_path)
def export_as_type(request, pootle_path, filetype):
"""export given file to xliff for offline translation"""
if pootle_path[0] != '/':
pootle_path = '/' + pootle_path
store = get_object_or_404(Store, pootle_path=pootle_path)
klass = factory_classes.get(filetype, None)
if not klass or is_monolingual(klass) or pootle_path.endswith(filetype):
raise ValueError
path, ext = os.path.splitext(store.real_path)
export_path = os.path.join('POOTLE_EXPORT',
path + os.path.extsep + filetype)
abs_export_path = absolute_real_path(export_path)
key = iri_to_uri("%s:export_as_%s" % (pootle_path, filetype))
last_export = cache.get(key)
if not (last_export and last_export == store.get_mtime()
and os.path.isfile(abs_export_path)):
ensure_target_dir_exists(abs_export_path)
outputstore = store.convert(klass)
fd, tempstore = tempfile.mkstemp(prefix=store.name,
suffix=os.path.extsep + filetype)
os.close(fd)
outputstore.savefile(tempstore)
shutil.move(tempstore, abs_export_path)
cache.set(key, store.get_mtime(), settings.OBJECT_CACHE_TIMEOUT)
return redirect('/export/' + export_path)
def display_page(request, virtual_path):
"""Displays an active page defined in `virtual_path`."""
page = None
for page_model in AbstractPage.__subclasses__():
try:
page = page_model.objects.live(request.user).get(
virtual_path=virtual_path,
)
except ObjectDoesNotExist:
pass
if page is None:
raise Http404
if page.url:
return redirect(page.url)
if request.user.is_superuser and not page.active:
msg = _('This page is inactive and visible to administrators '
'only. You can activate it by <a href="%s">editing its '
'properties</a>', page.get_edit_url())
messages.warning(request, msg)
template_name = 'staticpages/page_display.html'
if request.is_ajax():
template_name = 'staticpages/_body.html'
ctx = {
'page': page,
}
return render_to_response(template_name, ctx, RequestContext(request))
def commit_file(request, translation_project, file_path):
if not check_permission("commit", request):
raise PermissionDenied(_("You do not have rights to commit files here"))
pootle_path = translation_project.directory.pootle_path + file_path
store = get_object_or_404(Store, pootle_path=pootle_path)
result = translation_project.commitpofile(request.user, store)
return redirect(translation_project.directory.pootle_path)
def export_zip(request, translation_project, file_path):
translation_project.sync()
pootle_path = translation_project.pootle_path + (file_path or '')
archivename = '%s-%s' % (translation_project.project.code,
translation_project.language.code)
if file_path.endswith('/'):
file_path = file_path[:-1]
if file_path:
archivename += '-' + file_path.replace('/', '-')
archivename += '.zip'
export_path = os.path.join('POOTLE_EXPORT', translation_project.real_path,
archivename)
abs_export_path = absolute_real_path(export_path)
key = iri_to_uri("%s:export_zip" % pootle_path)
last_export = cache.get(key)
if (not (last_export and last_export == translation_project.get_mtime() and
os.path.isfile(abs_export_path))):
ensure_target_dir_exists(abs_export_path)
stores = Store.objects.filter(pootle_path__startswith=pootle_path) \
.exclude(file='')
translation_project.get_archive(stores, abs_export_path)
cache.set(key, translation_project.get_mtime(),
settings.OBJECT_CACHE_TIMEOUT)
return redirect('/export/' + export_path)
def update_file(request, translation_project, file_path):
if not check_permission("commit", request):
raise PermissionDenied(_("You do not have rights to update files here"))
pootle_path = translation_project.directory.pootle_path + file_path
store = get_object_or_404(Store, pootle_path=pootle_path)
result = translation_project.update_file(request, store)
return redirect(dispatch.show_directory(request, translation_project.directory.pootle_path))
def sso_return_view(request, redirect_to='', create=0):
redirect_to = '/%s' % redirect_to.lstrip('/')
d = get_cookie_dict(request)
if d:
ea = EvernoteAccount.objects.filter(**{'evernote_id': d['id']})
if len(ea) == 0:
if not create:
users = User.objects.filter(email=d['email'])
pootle_username = users[0].email if len(users) == 1 else ''
return redirect('/accounts/evernote/login/link?%s' %
urlencode({auth.REDIRECT_FIELD_NAME: redirect_to}))
ea = EvernoteAccount(
evernote_id = d['id'],
email=d['email'],
name=d['name']
)
if request.user.is_authenticated():
ea.user = request.user
else:
# create new Pootle user
user = auth.authenticate(**{'evernote_account': ea})
auth.login(request, user)
ea.save()
else:
ea = ea[0]
if request.user.is_authenticated():
if request.user.id != ea.user.id:
# it's not possible to link account with another user_id
# TODO show error message
return redirect(redirect_to)
else:
user = auth.authenticate(**{'evernote_account': ea})
auth.login(request, user)
return redirect_after_login(request, redirect_to)
else:
return redirect('/accounts/evernote/login/?%s' %
urlencode({auth.REDIRECT_FIELD_NAME: redirect_to}))
def extract(request, translation_project):
"""generate glossary of common keywords and phrases from translation project"""
template_vars = {
'translation_project': translation_project,
'language': translation_project.language,
'project': translation_project.project,
'directory': translation_project.directory,
}
if request.method == 'POST' and request.POST['extract']:
extractor = TerminologyExtractor(
accelchars=translation_project.checker.config.accelmarkers,
sourcelanguage=str(
translation_project.project.source_language.code))
for store in translation_project.stores.iterator():
if store.name == 'pootle-terminology.po':
continue
extractor.processunits(store.units, store.pootle_path)
terms = extractor.extract_terms(create_termunit=create_termunit)
termunits = extractor.filter_terms(terms, nonstopmin=2)
store, created = Store.objects.get_or_create(
parent=translation_project.directory,
translation_project=translation_project,
name="pootle-terminology.po")
# lock file
oldstate = store.state
store.state = LOCKED
store.save()
if not created:
store.units.delete()
# calculate maximum terms
maxunits = int(
translation_project.getquickstats()['totalsourcewords'] * 0.02)
maxunits = min(
max(settings.MIN_AUTOTERMS, maxunits), settings.MAX_AUTOTERMS)
for index, (score, unit) in enumerate(termunits[:maxunits]):
unit.store = store
unit.index = index
#FIXME: what to do with score?
unit.save()
for suggestion in unit.pending_suggestions:
unit.add_suggestion(suggestion)
# unlock file
store.state = oldstate
if store.state < PARSED:
store.state = PARSED
store.save()
template_vars['store'] = store
template_vars['termcount'] = len(termunits)
return redirect(translation_project.pootle_path +
'terminology_manage.html')
return render_to_response(
"terminology/extract.html",
template_vars,
context_instance=RequestContext(request))
def redirect_after_login(request):
redirect_to = request.REQUEST.get(auth.REDIRECT_FIELD_NAME, None)
if not redirect_to or '://' in redirect_to or ' ' in redirect_to:
redirect_to = iri_to_uri('/accounts/%s/' % \
urlquote(request.user.username))
return redirect(redirect_to)
def redirect_after_login(request):
redirect_to = request.REQUEST.get(auth.REDIRECT_FIELD_NAME, None)
if not redirect_to or '://' in redirect_to or ' ' in redirect_to:
redirect_to = iri_to_uri('/accounts/%s/' % \
urlquote(request.user.username))
return redirect(redirect_to)
def redirect_after_login(request):
redirect_to = request.REQUEST.get(auth.REDIRECT_FIELD_NAME, None)
if not is_safe_url(url=redirect_to, host=request.get_host()):
redirect_to = iri_to_uri('/accounts/%s/' % \
urlquote(request.user.username))
return redirect(redirect_to)
def update_all(request, translation_project, dir_path):
if not check_permission("commit", request):
raise PermissionDenied(_("You do not have rights to update files here"))
pootle_path = translation_project.directory.pootle_path + dir_path
directory = get_object_or_404(Directory, pootle_path=pootle_path)
result = translation_project.update_dir(request, directory)
return redirect(directory.pootle_path)
def update_file(request, translation_project, file_path):
if not check_permission("commit", request):
raise PermissionDenied(
_("You do not have rights to update files here"))
pootle_path = translation_project.directory.pootle_path + file_path
store = get_object_or_404(Store, pootle_path=pootle_path)
result = translation_project.update_file(request, store)
return redirect(
dispatch.show_directory(request,
translation_project.directory.pootle_path))
def update_all(request, translation_project, dir_path):
if not check_permission("commit", request):
raise PermissionDenied(
_("You do not have rights to update files here"))
pootle_path = translation_project.directory.pootle_path + dir_path
directory = get_object_or_404(Directory, pootle_path=pootle_path)
result = translation_project.update_dir(request, directory)
return redirect(directory.pootle_path)
def commit_file(request, translation_project, file_path):
if not check_permission("commit", request):
raise PermissionDenied(
_("You do not have rights to commit files here"))
pootle_path = translation_project.directory.pootle_path + file_path
store = get_object_or_404(Store, pootle_path=pootle_path)
result = translation_project.commit_file(request.user, store, request)
return redirect(store.pootle_path)
def extract(request, translation_project):
"""generate glossary of common keywords and phrases from translation project"""
template_vars = {
'translation_project': translation_project,
'language': translation_project.language,
'project': translation_project.project,
'directory': translation_project.directory,
}
terminology_filename = get_terminology_filename(translation_project)
if request.method == 'POST' and request.POST['extract']:
from translate.tools.poterminology import TerminologyExtractor
extractor = TerminologyExtractor(accelchars=translation_project.checker.config.accelmarkers,
sourcelanguage=str(translation_project.project.source_language.code))
for store in translation_project.stores.iterator():
if store.is_terminology:
continue
extractor.processunits(store.units, store.pootle_path)
terms = extractor.extract_terms(create_termunit=create_termunit)
termunits = extractor.filter_terms(terms, nonstopmin=2)
store, created = Store.objects.get_or_create(parent=translation_project.directory,
translation_project=translation_project,
name=terminology_filename)
# lock file
oldstate = store.state
store.state = LOCKED
store.save()
if not created:
store.units.delete()
# calculate maximum terms
maxunits = int(translation_project.getquickstats()['totalsourcewords'] * 0.02)
maxunits = min(max(settings.MIN_AUTOTERMS, maxunits), settings.MAX_AUTOTERMS)
for index, (score, unit) in enumerate(termunits[:maxunits]):
unit.store = store
unit.index = index
#FIXME: what to do with score?
unit.save()
for suggestion in unit.pending_suggestions:
unit.add_suggestion(suggestion) # Touch=True which saves unit on every call
# unlock file
store.state = oldstate
if store.state < PARSED:
store.state = PARSED
store.save()
template_vars['store'] = store
template_vars['termcount'] = len(termunits)
from pootle_misc.baseurl import redirect
return redirect(translation_project.pootle_path + 'terminology_manage.html')
return render_to_response("terminology/extract.html", template_vars, context_instance=RequestContext(request))
def edit_personal_info(request):
if request.POST:
post = request.POST.copy()
user_form = UserForm(post, instance=request.user)
if user_form.is_valid():
user_form.save()
response = redirect('/accounts/'+request.user.username)
else:
user_form = UserForm(instance=request.user)
template_vars = {"form": user_form}
response = render_to_response('profiles/edit_personal.html', template_vars, context_instance=RequestContext(request))
return response
def vcs_update(request, translation_project, dir_path, filename):
current_path = translation_project.directory.pootle_path + dir_path
if filename:
current_path = current_path + filename
obj = get_object_or_404(Store, pootle_path=current_path)
result = translation_project.update_file(request, obj)
else:
obj = get_object_or_404(Directory, pootle_path=current_path)
result = translation_project.update_dir(request, obj)
return redirect(obj.get_absolute_url())
def vcs_update(request, translation_project, dir_path, filename):
current_path = translation_project.directory.pootle_path + dir_path
if filename:
current_path = current_path + filename
obj = get_object_or_404(Store, pootle_path=current_path)
result = translation_project.update_file(request, obj)
else:
obj = get_object_or_404(Directory, pootle_path=current_path)
result = translation_project.update_dir(request, obj)
return redirect(obj.get_absolute_url())
def edit_personal_info(request):
if request.POST:
post = request.POST.copy()
user_form = UserForm(post, instance=request.user)
if user_form.is_valid():
user_form.save()
response = redirect('/accounts/'+request.user.username)
else:
user_form = UserForm(instance=request.user)
template_vars = {"form": user_form}
response = render_to_response('profiles/edit_personal.html', template_vars, context_instance=RequestContext(request))
return response
def edit_personal_info(request):
if request.POST:
post = request.POST.copy()
user_form = UserForm(post, instance=request.user)
if user_form.is_valid():
user_form.save()
redirect_url = reverse("profiles_profile_detail", kwargs={"username": request.user.username})
response = redirect(redirect_url)
else:
user_form = UserForm(instance=request.user)
ctx = {"form": user_form}
return render_to_response("profiles/settings/personal.html", ctx, context_instance=RequestContext(request))
def edit_personal_info(request):
if request.POST:
post = request.POST.copy()
user_form = UserForm(post, instance=request.user)
if user_form.is_valid():
user_form.save()
redirect_url = reverse('profiles_profile_detail',
kwargs={'username': request.user.username})
response = redirect(redirect_url)
else:
user_form = UserForm(instance=request.user)
ctx = {
'form': user_form,
}
return render_to_response('profiles/settings/personal.html', ctx,
context_instance=RequestContext(request))
def export_as_xliff(request, pootle_path):
"""export given file to xliff for offline translation"""
if pootle_path[0] != '/':
pootle_path = '/' + pootle_path
store = get_object_or_404(Store, pootle_path=pootle_path)
path, ext = os.path.splitext(store.real_path)
export_path = os.path.join('POOTLE_EXPORT', path + os.path.extsep + 'xlf')
abs_export_path = absolute_real_path(export_path)
key = "%s:export_as_xliff"
last_export = cache.get(key)
if not (last_export and last_export == store.get_mtime() and os.path.isfile(abs_export_path)):
ensure_target_dir_exists(abs_export_path)
outputstore = store.convert(PoXliffFile)
outputstore.switchfile(store.name, createifmissing=True)
fd, tempstore = tempfile.mkstemp(prefix=store.name, suffix='.xlf')
os.close(fd)
outputstore.savefile(tempstore)
shutil.move(tempstore, abs_export_path)
cache.set(key, store.get_mtime(), settings.OBJECT_CACHE_TIMEOUT)
return redirect('/export/' + export_path)
def export_as_xliff(request, store):
"""export given file to xliff for offline translation"""
path, ext = os.path.splitext(store.real_path)
export_path = os.path.join('POOTLE_EXPORT', path + os.path.extsep + 'xlf')
abs_export_path = absolute_real_path(export_path)
key = iri_to_uri("%s:export_as_xliff" % store.pootle_path)
last_export = cache.get(key)
if not (last_export and last_export == store.get_mtime() and os.path.isfile(abs_export_path)):
from pootle_app.project_tree import ensure_target_dir_exists
from translate.storage.poxliff import PoXliffFile
import tempfile
import shutil
ensure_target_dir_exists(abs_export_path)
outputstore = store.convert(PoXliffFile)
outputstore.switchfile(store.name, createifmissing=True)
fd, tempstore = tempfile.mkstemp(prefix=store.name, suffix='.xlf')
os.close(fd)
outputstore.savefile(tempstore)
shutil.move(tempstore, abs_export_path)
cache.set(key, store.get_mtime(), settings.OBJECT_CACHE_TIMEOUT)
return redirect('/export/' + export_path)
def export_as_xliff(request, pootle_path):
"""export given file to xliff for offline translation"""
if pootle_path[0] != '/':
pootle_path = '/' + pootle_path
store = get_object_or_404(Store, pootle_path=pootle_path)
path, ext = os.path.splitext(store.real_path)
export_path = os.path.join('POOTLE_EXPORT', path + os.path.extsep + 'xlf')
abs_export_path = absolute_real_path(export_path)
key = iri_to_uri("%s:export_as_xliff" % pootle_path)
last_export = cache.get(key)
if not (last_export and last_export == store.get_mtime()
and os.path.isfile(abs_export_path)):
ensure_target_dir_exists(abs_export_path)
outputstore = store.convert(PoXliffFile)
outputstore.switchfile(store.name, createifmissing=True)
fd, tempstore = tempfile.mkstemp(prefix=store.name, suffix='.xlf')
os.close(fd)
outputstore.savefile(tempstore)
shutil.move(tempstore, abs_export_path)
cache.set(key, store.get_mtime(), settings.OBJECT_CACHE_TIMEOUT)
return redirect('/export/' + export_path)
def export_zip(request, translation_project, file_path):
from django.utils.timezone import utc
translation_project.sync()
pootle_path = translation_project.pootle_path + (file_path or '')
archivename = '%s-%s' % (translation_project.project.code,
translation_project.language.code)
if file_path.endswith('/'):
file_path = file_path[:-1]
if file_path:
archivename += '-' + file_path.replace('/', '-')
archivename += '.zip'
export_path = os.path.join('POOTLE_EXPORT', translation_project.real_path,
archivename)
abs_export_path = absolute_real_path(export_path)
key = iri_to_uri("%s:export_zip" % pootle_path)
last_export = cache.get(key)
tp_time = translation_project.get_mtime().replace(tzinfo=utc)
up_to_date = False
if last_export:
# Make both datetimes tz-aware to avoid a crash here
last_export = last_export.replace(tzinfo=utc)
up_to_date = last_export == tp_time
if (not (up_to_date and os.path.isfile(abs_export_path))):
ensure_target_dir_exists(abs_export_path)
stores = Store.objects.filter(pootle_path__startswith=pootle_path) \
.exclude(file='')
translation_project.get_archive(stores, abs_export_path)
cache.set(key, tp_time, settings.OBJECT_CACHE_TIMEOUT)
return redirect('/export/' + export_path)
def extract(request, translation_project):
"""Generate glossary of common keywords and phrases from translation
project.
"""
ctx = {
'page': 'admin-terminology',
'translation_project': translation_project,
'language': translation_project.language,
'project': translation_project.project,
'directory': translation_project.directory,
}
if request.method == 'POST' and request.POST['extract']:
from translate.tools.poterminology import TerminologyExtractor
extractor = TerminologyExtractor(
accelchars=translation_project.checker.config.accelmarkers,
sourcelanguage=str(translation_project.project.source_language.code)
)
for store in translation_project.stores.iterator():
if store.is_terminology:
continue
extractor.processunits(store.units, store.pootle_path)
terms = extractor.extract_terms(create_termunit=create_termunit)
termunits = extractor.filter_terms(terms, nonstopmin=2)
store, created = Store.objects.get_or_create(
parent=translation_project.directory,
translation_project=translation_project,
name=get_terminology_filename(translation_project),
)
# Lock file.
oldstate = store.state
store.state = LOCKED
store.save()
if not created:
store.units.delete()
# Calculate maximum terms.
maxunits = int(translation_project.get_total_wordcount() * 0.02)
maxunits = min(max(settings.MIN_AUTOTERMS, maxunits),
settings.MAX_AUTOTERMS)
for index, (score, unit) in enumerate(termunits[:maxunits]):
unit.store = store
unit.index = index
#FIXME: what to do with score?
unit.save()
for suggestion in unit.pending_suggestions:
# Touch=True which saves unit on every call.
unit.add_suggestion(suggestion)
# Unlock file.
store.state = oldstate
if store.state < PARSED:
store.state = PARSED
store.save()
ctx.update({
'store': store,
'termcount': len(termunits),
})
path_args = split_pootle_path(translation_project.pootle_path)[:2]
return redirect(reverse('pootle-terminology-manage', args=path_args))
template_name = 'translation_projects/terminology/extract.html'
return render_to_response(template_name, ctx,
context_instance=RequestContext(request))
def download(request, store):
store.sync(update_translation=True)
return redirect('/export/' + store.real_path)
def extract(request, translation_project):
"""Generate glossary of common keywords and phrases from translation
project.
"""
ctx = {
'translation_project': translation_project,
'language': translation_project.language,
'project': translation_project.project,
'directory': translation_project.directory,
}
if request.method == 'POST' and request.POST['extract']:
from translate.tools.poterminology import TerminologyExtractor
extractor = TerminologyExtractor(
accelchars=translation_project.checker.config.accelmarkers,
sourcelanguage=str(translation_project.project.source_language.code)
)
for store in translation_project.stores.iterator():
if store.is_terminology:
continue
extractor.processunits(store.units, store.pootle_path)
terms = extractor.extract_terms(create_termunit=create_termunit)
termunits = extractor.filter_terms(terms, nonstopmin=2)
store, created = Store.objects.get_or_create(
parent=translation_project.directory,
translation_project=translation_project,
name=get_terminology_filename(translation_project),
)
# Lock file.
oldstate = store.state
store.state = LOCKED
store.save()
if not created:
store.units.delete()
# Calculate maximum terms.
maxunits = int(translation_project.get_total_wordcount() * 0.02)
maxunits = min(max(settings.MIN_AUTOTERMS, maxunits),
settings.MAX_AUTOTERMS)
for index, (score, unit) in enumerate(termunits[:maxunits]):
unit.store = store
unit.index = index
#FIXME: what to do with score?
unit.save()
for suggestion in unit.pending_suggestions:
# Touch=True which saves unit on every call.
unit.add_suggestion(suggestion)
# Unlock file.
store.state = oldstate
if store.state < PARSED:
store.state = PARSED
store.save()
ctx.update({
'store': store,
'termcount': len(termunits),
})
path_args = split_pootle_path(translation_project.pootle_path)[:2]
return redirect(reverse('pootle-terminology-manage', args=path_args))
template_name = 'translation_projects/terminology/extract.html'
return render_to_response(template_name, ctx,
context_instance=RequestContext(request))
def logout(request):
from django.contrib.auth import logout
logout(request)
return redirect('/')
def download(request, pootle_path):
if pootle_path[0] != '/':
pootle_path = '/' + pootle_path
store = get_object_or_404(Store, pootle_path=pootle_path)
store.sync(update_translation=True)
return redirect('/export/' + store.real_path)
def download(request, pootle_path):
if pootle_path[0] != '/':
pootle_path = '/' + pootle_path
store = get_object_or_404(Store, pootle_path=pootle_path)
store.sync(update_translation=True)
return redirect('/export/' + store.real_path)
def redirect_after_login(request, redirect_to):
if not redirect_to or '://' in redirect_to or ' ' in redirect_to:
redirect_to = iri_to_uri('/accounts/%s/' % \
urlquote(request.user.username))
return redirect(redirect_to)
def logout(request):
from django.contrib.auth import logout
logout(request)
return redirect('/')
def extract(request, translation_project):
"""Generate glossary of common keywords and phrases from translation
project.
"""
template_vars = {
'translation_project': translation_project,
'language': translation_project.language,
'project': translation_project.project,
'directory': translation_project.directory,
}
if request.method == 'POST' and request.POST['extract']:
from translate.tools.poterminology import TerminologyExtractor
terminology_extractor_params = {
'accelchars': translation_project.checker.config.accelmarkers,
'sourcelanguage': str(translation_project.project.source_language.code),
}
extractor = TerminologyExtractor(**terminology_extractor_params)
for store in translation_project.stores.iterator():
if store.is_terminology:
continue
extractor.processunits(store.units, store.pootle_path)
terms = extractor.extract_terms(create_termunit=create_termunit)
termunits = extractor.filter_terms(terms, nonstopmin=2)
create_criteria = {
'parent': translation_project.directory,
'translation_project': translation_project,
'name': get_terminology_filename(translation_project),
}
store, created = Store.objects.get_or_create(**create_criteria)
# lock file
oldstate = store.state
store.state = LOCKED
store.save()
if not created:
store.units.delete()
# calculate maximum terms
maxunits = int(translation_project.getquickstats()['totalsourcewords'] * 0.02)
maxunits = min(max(settings.MIN_AUTOTERMS, maxunits), settings.MAX_AUTOTERMS)
for index, (score, unit) in enumerate(termunits[:maxunits]):
unit.store = store
unit.index = index
#FIXME: what to do with score?
unit.save()
for suggestion in unit.pending_suggestions:
# Touch=True which saves unit on every call
unit.add_suggestion(suggestion)
# unlock file
store.state = oldstate
if store.state < PARSED:
store.state = PARSED
store.save()
template_vars['store'] = store
template_vars['termcount'] = len(termunits)
from pootle_misc.baseurl import redirect
return redirect(translation_project.pootle_path +
'terminology_manage.html')
return render_to_response("terminology/extract.html", template_vars,
context_instance=RequestContext(request))
