def handle(self, *args, **options):
try:
self.schema_tool = SchemaTool(*args)
except (LookupError, ImportError) as e:
raise CommandError("%s. Are you sure your INSTALLED_APPS "
"setting is correct?" % e)
if options['tables']:
result = dict(apps={})
for app_label in args:
result['apps'] = {
'name': app_label,
'tables': self.schema_tool.get_app_tables(app_label),
}
self.stdout.write(jsonify(result))
else:
result = dict(apps={})
for app_label in args:
result['apps'][app_label] = {
'name': app_label,
'tables': {}
}
for table_name in self.schema_tool.get_app_tables(app_label):
result['apps'][app_label]['tables'].update(
self.handle_table(table_name, **options)
)
self.stdout.write(jsonify(result))
def test_schema_app(capfd):
call_command('schema', 'app', 'pootle_store')
out, err = capfd.readouterr()
schema_tool = SchemaTool('pootle_store')
for table_name in schema_tool.get_tables():
assert jsonify(schema_tool.get_table_fields(table_name)) in out
assert jsonify(schema_tool.get_table_indices(table_name)) in out
assert jsonify(schema_tool.get_table_constraints(table_name)) in out
def handle(self, **options):
schema_tool = SchemaTool()
if options['tables']:
self.stdout.write(jsonify(schema_tool.get_tables()))
else:
self.stdout.write(
jsonify(schema_tool.get_defaults())
)
def test_schema_table(capfd):
call_command('schema', 'table', 'pootle_store_store')
out, err = capfd.readouterr()
schema_tool = SchemaTool()
assert jsonify(schema_tool.get_table_fields('pootle_store_store')) in out
assert jsonify(schema_tool.get_table_indices('pootle_store_store')) in out
assert jsonify(
schema_tool.get_table_constraints('pootle_store_store')) in out
def browse(request, language):
user_tps = language.get_children_for_user(request.user)
items = (make_project_item(tp) for tp in user_tps)
table_fields = [
'name', 'progress', 'total', 'need-translation', 'suggestions',
'critical', 'last-updated', 'activity'
]
ctx = get_browser_context(request)
ctx.update({
'language': {
'code': language.code,
'name': tr_lang(language.fullname),
},
'table': {
'id': 'language',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': items,
},
'stats':
jsonify(request.resource_obj.get_stats_for_user(request.user)),
'browser_extends':
'languages/base.html',
})
response = render(request, 'browser/index.html', ctx)
response.set_cookie('pootle-language', language.code)
return response
def projects_browse(request, project_set):
"""Page listing all projects"""
items = [make_project_list_item(project)
for project in project_set.children]
items.sort(lambda x, y: locale.strcoll(x['title'], y['title']))
table_fields = ['name', 'progress', 'total', 'need-translation',
'suggestions', 'critical', 'last-updated', 'activity']
table = {
'id': 'projects',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': items,
}
ctx = get_browser_context(request)
ctx.update({
'table': table,
'stats': jsonify(request.resource_obj.get_stats()),
'browser_extends': 'projects/all/base.html',
})
response = render(request, 'browser/index.html', ctx)
response.set_cookie('pootle-language', 'projects')
return response
def projects_browse(request, project_set):
"""Page listing all projects"""
items = [
make_project_list_item(project) for project in project_set.children
]
items.sort(lambda x, y: locale.strcoll(x['title'], y['title']))
table_fields = [
'name', 'progress', 'total', 'need-translation', 'suggestions',
'critical', 'last-updated', 'activity'
]
table = {
'id': 'projects',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': items,
}
ctx = get_browser_context(request)
ctx.update({
'table': table,
'stats': jsonify(request.resource_obj.get_stats()),
'browser_extends': 'projects/all/base.html',
})
response = render(request, 'browser/index.html', ctx)
response.set_cookie('pootle-language', 'projects')
return response
def browse(request, project, dir_path, filename):
"""Languages browser for a given project."""
item_func = (make_xlanguage_item if dir_path or filename
else make_language_item)
items = [item_func(item) for item in
request.resource_obj.get_children_for_user(request.profile)]
items.sort(lambda x, y: locale.strcoll(x['title'], y['title']))
table_fields = ['name', 'progress', 'total', 'need-translation',
'suggestions', 'critical', 'last-updated', 'activity']
table = {
'id': 'project',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': items,
}
ctx = get_browser_context(request)
ctx.update({
'project': project,
'table': table,
'stats': jsonify(request.resource_obj.get_stats()),
'browser_extends': 'projects/base.html',
})
return render(request, 'browser/index.html', ctx)
def authentication_error(self,
request,
provider_id,
error=None,
exception=None,
extra_context=None):
provider = providers.registry.by_id(provider_id)
retry_url = provider.get_login_url(request,
**dict(request.GET.iteritems()))
tb = traceback.format_exc()
log_exception(request, exception, tb)
ctx = {
'social_error':
jsonify({
'error': error,
'exception': {
'name': exception.__class__.__name__,
'msg': unicode(exception),
},
'provider': provider.name,
'retry_url': retry_url,
}),
}
raise ImmediateHttpResponse(
response=render(request, 'account/social_error.html', ctx))
def pootle_context(request):
"""Exposes settings to templates."""
# FIXME: maybe we should expose relevant settings only?
return {
'settings': {
'POOTLE_TITLE':
settings.POOTLE_TITLE,
'POOTLE_INSTANCE_ID':
settings.POOTLE_INSTANCE_ID,
'POOTLE_CONTACT_ENABLED': (settings.POOTLE_CONTACT_ENABLED
and settings.POOTLE_CONTACT_EMAIL),
'POOTLE_MARKUP_FILTER':
get_markup_filter_name(),
'POOTLE_SIGNUP_ENABLED':
settings.POOTLE_SIGNUP_ENABLED,
'SCRIPT_NAME':
settings.SCRIPT_NAME,
'POOTLE_CACHE_TIMEOUT':
settings.POOTLE_CACHE_TIMEOUT,
'DEBUG':
settings.DEBUG,
},
'custom': settings.POOTLE_CUSTOM_TEMPLATE_CONTEXT,
'ALL_LANGUAGES': Language.live.cached_dict(translation.get_language()),
'ALL_PROJECTS': Project.objects.cached_dict(request.user),
'SOCIAL_AUTH_PROVIDERS': jsonify(_get_social_auth_providers(request)),
'display_agreement': _agreement_context(request),
}
def browse(request, language):
translation_projects = language.children \
.order_by('project__fullname')
user_tps = filter(lambda x: x.is_accessible_by(request.user),
translation_projects)
items = (make_project_item(tp) for tp in user_tps)
table_fields = ['name', 'progress', 'total', 'need-translation',
'suggestions', 'critical', 'last-updated', 'activity']
ctx = get_browser_context(request)
ctx.update({
'language': {
'code': language.code,
'name': tr_lang(language.fullname),
},
'table': {
'id': 'language',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': items,
},
'stats': jsonify(request.resource_obj.get_stats()),
'browser_extends': 'languages/base.html',
})
response = render(request, 'browser/index.html', ctx)
response.set_cookie('pootle-language', language.code)
return response
def browse(request, project, dir_path, filename):
"""Languages browser for a given project."""
item_func = (make_xlanguage_item
if dir_path or filename else make_language_item)
items = [
item_func(item)
for item in request.resource_obj.get_children_for_user(request.profile)
]
items.sort(lambda x, y: locale.strcoll(x['title'], y['title']))
table_fields = [
'name', 'progress', 'total', 'need-translation', 'suggestions',
'critical', 'last-updated', 'activity'
]
table = {
'id': 'project',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': items,
}
ctx = get_browser_context(request)
ctx.update({
'project': project,
'table': table,
'stats': jsonify(request.resource_obj.get_stats()),
'browser_extends': 'projects/base.html',
})
return render(request, 'browser/index.html', ctx)
def reports(request):
User = get_user_model()
now = make_aware(datetime.now())
ctx = {
'page':
'admin-reports',
'users':
jsonify(
map(lambda x: {
'id': x.username,
'text': x.formatted_name
}, User.objects.hide_meta())),
'user_rates_form':
UserRatesForm(),
'paid_task_form':
PaidTaskForm(),
'now':
now.strftime('%Y-%m-%d %H:%M:%S'),
'admin_report':
True,
'paid_task_types':
PaidTaskTypes,
}
return render_to_response('admin/reports.html',
ctx,
context_instance=RequestContext(request))
def _test_browse_view(project, request, response, kwargs):
cookie_data = json.loads(
unquote(response.cookies[SIDEBAR_COOKIE_NAME].value))
assert cookie_data["foo"] == "bar"
assert "announcements_projects_%s" % project.code in cookie_data
ctx = response.context
kwargs["project_code"] = project.code
resource_path = ("%(dir_path)s%(filename)s" % kwargs)
project_path = ("%s/%s" % (kwargs["project_code"], resource_path))
if not (kwargs["dir_path"] or kwargs["filename"]):
ob = project
elif not kwargs["filename"]:
ob = ProjectResource(Directory.objects.live().filter(
pootle_path__regex="^/.*/%s$" % project_path),
pootle_path="/projects/%s" % project_path)
else:
ob = ProjectResource(Store.objects.live().filter(
pootle_path__regex="^/.*/%s$" % project_path),
pootle_path="/projects/%s" % project_path)
item_func = (make_xlanguage_item if
(kwargs["dir_path"]
or kwargs["filename"]) else make_language_item)
items = [
item_func(item) for item in ob.get_children_for_user(request.user)
]
items.sort(lambda x, y: locale.strcoll(x['title'], y['title']))
table_fields = [
'name', 'progress', 'total', 'need-translation', 'suggestions',
'critical', 'last-updated', 'activity'
]
table = {
'id': 'project',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': items
}
assertions = dict(
page="browse",
project=project,
browser_extends="projects/base.html",
pootle_path="/projects/%s" % project_path,
resource_path=resource_path,
resource_path_parts=get_path_parts(resource_path),
url_action_continue=ob.get_translate_url(state='incomplete'),
url_action_fixcritical=ob.get_critical_url(),
url_action_review=ob.get_translate_url(state='suggestions'),
url_action_view_all=ob.get_translate_url(state='all'),
translation_states=get_translation_states(ob),
check_categories=get_qualitycheck_schema(ob),
table=table,
stats=jsonify(ob.get_stats()))
sidebar = get_sidebar_announcements_context(request, (project, ))
for k in ["has_sidebar", "is_sidebar_open", "announcements"]:
assertions[k] = sidebar[0][k]
view_context_test(ctx, **assertions)
def _test_browse_view(project, request, response, kwargs):
cookie_data = json.loads(unquote(response.cookies[SIDEBAR_COOKIE_NAME].value))
assert cookie_data["foo"] == "bar"
assert "announcements_projects_%s" % project.code in cookie_data
ctx = response.context
kwargs["project_code"] = project.code
resource_path = "%(dir_path)s%(filename)s" % kwargs
project_path = "%s/%s" % (kwargs["project_code"], resource_path)
if not (kwargs["dir_path"] or kwargs["filename"]):
ob = project
elif not kwargs["filename"]:
ob = ProjectResource(
Directory.objects.live().filter(pootle_path__regex="^/.*/%s$" % project_path),
pootle_path="/projects/%s" % project_path,
)
else:
ob = ProjectResource(
Store.objects.live().filter(pootle_path__regex="^/.*/%s$" % project_path),
pootle_path="/projects/%s" % project_path,
)
item_func = make_xlanguage_item if (kwargs["dir_path"] or kwargs["filename"]) else make_language_item
items = [item_func(item) for item in ob.get_children_for_user(request.profile)]
items.sort(lambda x, y: locale.strcoll(x["title"], y["title"]))
table_fields = [
"name",
"progress",
"total",
"need-translation",
"suggestions",
"critical",
"last-updated",
"activity",
]
table = {"id": "project", "fields": table_fields, "headings": get_table_headings(table_fields), "items": items}
assertions = dict(
page="browse",
project=project,
resource_obj=ob,
browser_extends="projects/base.html",
pootle_path="/projects/%s" % project_path,
resource_path=resource_path,
resource_path_parts=get_path_parts(resource_path),
url_action_continue=ob.get_translate_url(state="incomplete"),
url_action_fixcritical=ob.get_critical_url(),
url_action_review=ob.get_translate_url(state="suggestions"),
url_action_view_all=ob.get_translate_url(state="all"),
translation_states=get_translation_states(ob),
check_categories=get_qualitycheck_schema(ob),
table=table,
stats=jsonify(ob.get_stats()),
)
sidebar = get_sidebar_announcements_context(request, (project,))
for k in ["has_sidebar", "is_sidebar_open", "announcements"]:
assertions[k] = sidebar[0][k]
view_context_test(ctx, **assertions)
def test_view_projects_browse(client, request_users):
user = request_users["user"]
client.login(
username=user.username,
password=request_users["password"])
response = client.get(reverse("pootle-projects-browse"))
assert response.cookies["pootle-language"].value == "projects"
ctx = response.context
request = response.wsgi_request
user_projects = Project.accessible_by_user(request.user)
user_projects = (
Project.objects.for_user(request.user)
.filter(code__in=user_projects))
ob = ProjectSet(user_projects)
items = [
make_project_list_item(project)
for project in ob.children]
items.sort(lambda x, y: locale.strcoll(x['title'], y['title']))
table_fields = [
'name', 'progress', 'total', 'need-translation',
'suggestions', 'critical', 'last-updated', 'activity']
table = {
'id': 'projects',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': items}
if request.user.is_superuser:
url_action_continue = ob.get_translate_url(state='incomplete')
url_action_fixcritical = ob.get_critical_url()
url_action_review = ob.get_translate_url(state='suggestions')
url_action_view_all = ob.get_translate_url(state='all')
else:
(url_action_continue,
url_action_fixcritical,
url_action_review,
url_action_view_all) = [None] * 4
assertions = dict(
page="browse",
pootle_path="/projects/",
resource_path="",
resource_path_parts=[],
object=ob,
table=table,
browser_extends="projects/all/base.html",
stats=jsonify(ob.get_stats()),
check_categories=get_qualitycheck_schema(ob),
translation_states=get_translation_states(ob),
url_action_continue=url_action_continue,
url_action_fixcritical=url_action_fixcritical,
url_action_review=url_action_review,
url_action_view_all=url_action_view_all)
view_context_test(ctx, **assertions)
def test_view_projects_browse(client, request_users):
user = request_users["user"]
client.login(
username=user.username,
password=request_users["password"])
response = client.get(reverse("pootle-projects-browse"))
assert response.cookies["pootle-language"].value == "projects"
ctx = response.context
request = response.wsgi_request
user_projects = Project.accessible_by_user(request.user)
user_projects = (
Project.objects.for_user(request.user)
.filter(code__in=user_projects))
ob = ProjectSet(user_projects)
items = [
make_project_list_item(project)
for project in ob.children]
items.sort(lambda x, y: locale.strcoll(x['title'], y['title']))
table_fields = [
'name', 'progress', 'total', 'need-translation',
'suggestions', 'critical', 'last-updated', 'activity']
table = {
'id': 'projects',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': items}
if request.user.is_superuser:
url_action_continue = ob.get_translate_url(state='incomplete')
url_action_fixcritical = ob.get_critical_url()
url_action_review = ob.get_translate_url(state='suggestions')
url_action_view_all = ob.get_translate_url(state='all')
else:
(url_action_continue,
url_action_fixcritical,
url_action_review,
url_action_view_all) = [None] * 4
assertions = dict(
page="browse",
pootle_path="/projects/",
resource_path="",
resource_path_parts=[],
object=ob,
table=table,
browser_extends="projects/all/base.html",
stats=jsonify(ob.get_stats()),
check_categories=get_qualitycheck_schema(ob),
translation_states=get_translation_states(ob),
url_action_continue=url_action_continue,
url_action_fixcritical=url_action_fixcritical,
url_action_review=url_action_review,
url_action_view_all=url_action_view_all)
view_context_test(ctx, **assertions)
def handle_translation_project(self, tp, **options):
stats = options.get('stats', False)
data = options.get('data', False)
stop_level = int(options.get('stop_level', -1))
if stats:
res = {}
self._dump_stats(tp.directory, res, stop_level=stop_level)
stats_dump = jsonify(res)
self.stdout.write(stats_dump)
if data:
self._dump_item(tp.directory, 0, stop_level=stop_level)
def handle(self, *args, **options):
self.schema_tool = SchemaTool()
all_tables = self.schema_tool.get_tables()
if not set(args).issubset(set(all_tables)):
raise CommandError("Unrecognized tables: %s" %
list(set(args) - set(all_tables)))
result = {}
for table_name in args:
result.update(
self.handle_table(table_name, **options)
)
self.stdout.write(jsonify(result))
def create_api_request(rf, method='get', url='/', data='', user=None,
encode_as_json=True):
"""Convenience function to create and setup fake requests."""
content_type = 'application/x-www-form-urlencoded'
if data and encode_as_json:
from pootle.core.utils.json import jsonify
content_type = 'application/json'
data = jsonify(data)
request_method = getattr(rf, method.lower())
request = request_method(url, data=data, content_type=content_type)
request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
if user is not None:
request.user = user
return request
def evernote_reports(request):
User = get_user_model()
now = make_aware(datetime.now())
ctx = {
'users': jsonify(map(
lambda x: {'id': x.username, 'text': escape(x.formatted_name)},
User.objects.hide_meta()
)),
'user_rates_form': UserRatesForm(),
'paid_task_form': PaidTaskForm(),
'now': now.strftime('%Y-%m-%d %H:%M:%S'),
'admin_report': True,
'paid_task_types': PaidTaskTypes,
}
return render_to_response('admin/reports.html', ctx,
context_instance=RequestContext(request))
def get_context_data(self, **kwargs):
languages = Language.objects.exclude(code='templates')
language_choices = [(lang.id, unicode(lang)) for lang in languages]
try:
english = Language.objects.get(code='en')
default_language = english.id
except Language.DoesNotExist:
default_language = languages[0].id
kwargs['form_choices'] = jsonify({
'checkstyle': Project.checker_choices,
'localfiletype': filetype_choices,
'source_language': language_choices,
'treestyle': Project.treestyle_choices,
'defaults': {
'source_language': default_language,
},
})
return kwargs
def _test_browse_view(language, request, response, kwargs):
assert (response.cookies["pootle-language"].value == language.code)
cookie_data = json.loads(
unquote(response.cookies[SIDEBAR_COOKIE_NAME].value))
assert cookie_data["foo"] == "bar"
assert "announcements_%s" % language.code in cookie_data
ctx = response.context
table_fields = [
'name', 'progress', 'total', 'need-translation', 'suggestions',
'critical', 'last-updated', 'activity'
]
user_tps = language.get_children_for_user(request.user)
items = [make_project_item(tp) for tp in user_tps]
table = {
'id': 'language',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': items
}
assertions = dict(
page="browse",
object=language,
language={
'code': language.code,
'name': language.name
},
browser_extends="languages/base.html",
pootle_path="/%s/" % language.code,
resource_path="",
resource_path_parts=[],
url_action_continue=language.get_translate_url(state='incomplete'),
url_action_fixcritical=language.get_critical_url(),
url_action_review=language.get_translate_url(state='suggestions'),
url_action_view_all=language.get_translate_url(state='all'),
# check_categories=get_qualitycheck_schema(language),
table=table,
translation_states=get_translation_states(language),
stats=jsonify(language.get_stats_for_user(request.user)))
sidebar = get_sidebar_announcements_context(request, (language, ))
for k in ["has_sidebar", "is_sidebar_open", "announcements"]:
assertions[k] = sidebar[0][k]
view_context_test(ctx, **assertions)
def _test_browse_view(language, request, response, kwargs):
assert (
response.cookies["pootle-language"].value == language.code)
cookie_data = json.loads(
unquote(response.cookies[SIDEBAR_COOKIE_NAME].value))
assert cookie_data["foo"] == "bar"
assert "announcements_%s" % language.code in cookie_data
ctx = response.context
table_fields = [
'name', 'progress', 'total', 'need-translation',
'suggestions', 'critical', 'last-updated', 'activity']
user_tps = language.get_children_for_user(request.user)
items = [make_project_item(tp) for tp in user_tps]
table = {
'id': 'language',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': items}
assertions = dict(
page="browse",
object=language,
language={
'code': language.code,
'name': language.name},
browser_extends="languages/base.html",
pootle_path="/%s/" % language.code,
resource_path="",
resource_path_parts=[],
url_action_continue=language.get_translate_url(state='incomplete'),
url_action_fixcritical=language.get_critical_url(),
url_action_review=language.get_translate_url(state='suggestions'),
url_action_view_all=language.get_translate_url(state='all'),
# check_categories=get_qualitycheck_schema(language),
table=table,
translation_states=get_translation_states(language),
top_scorers=get_user_model().top_scorers(language=language.code, limit=10),
stats=jsonify(language.get_stats_for_user(request.user)))
sidebar = get_sidebar_announcements_context(
request, (language, ))
for k in ["has_sidebar", "is_sidebar_open", "announcements"]:
assertions[k] = sidebar[0][k]
view_context_test(ctx, **assertions)
def authentication_error(self, request, provider_id, error=None,
exception=None, extra_context=None):
provider = providers.registry.by_id(provider_id)
retry_url = provider.get_login_url(request,
**dict(request.GET.iteritems()))
ctx = {
'social_error': jsonify({
'error': error,
'exception': {
'name': exception.__class__.__name__,
'msg': exception.message,
},
'provider': provider.name,
'retry_url': retry_url,
}),
}
raise ImmediateHttpResponse(
response=render(request, 'account/social_error.html', ctx)
)
def test_duedate_post_fake_paths(client, admin, path):
"""Tests posting with fake/invalid paths.
This basically checks the logic behind `CanAdminPath`, but could probably
belong somewhere else too.
"""
url = "/xhr/duedates/"
post_data = {
"due_on": "2017-01-26",
"modified_by": admin.id,
"pootle_path": path,
}
client.force_login(admin)
response = client.post(url,
jsonify(post_data),
content_type="application/json")
assert response.status_code == 404
assert response.json() == {"msg": "Not found"}
def test_duedate_post_fake_paths(client, admin, path):
"""Tests posting with fake/invalid paths.
This basically checks the logic behind `CanAdminPath`, but could probably
belong somewhere else too.
"""
url = '/xhr/duedates/'
post_data = {
'due_on': '2017-01-26',
'modified_by': admin.id,
'pootle_path': path,
}
client.force_login(admin)
response = client.post(url,
jsonify(post_data),
content_type='application/json')
assert response.status_code == 404
assert response.json() == {'msg': 'Not found'}
def pootle_context(request):
"""Exposes settings to templates."""
# FIXME: maybe we should expose relevant settings only?
return {
'settings': {
'POOTLE_TITLE': settings.POOTLE_TITLE,
'POOTLE_INSTANCE_ID': settings.POOTLE_INSTANCE_ID,
'POOTLE_CONTACT_ENABLED': (settings.POOTLE_CONTACT_ENABLED and
settings.POOTLE_CONTACT_EMAIL),
'POOTLE_MARKUP_FILTER': get_markup_filter_name(),
'POOTLE_SIGNUP_ENABLED': settings.POOTLE_SIGNUP_ENABLED,
'SCRIPT_NAME': settings.SCRIPT_NAME,
'POOTLE_CACHE_TIMEOUT': settings.POOTLE_CACHE_TIMEOUT,
'DEBUG': settings.DEBUG,
},
'custom': settings.POOTLE_CUSTOM_TEMPLATE_CONTEXT,
'ALL_LANGUAGES': Language.live.cached_dict(translation.get_language()),
'ALL_PROJECTS': Project.objects.cached_dict(request.user),
'SOCIAL_AUTH_PROVIDERS': jsonify(_get_social_auth_providers(request)),
'display_agreement': _agreement_context(request),
}
def create_api_request(rf,
method='get',
url='/',
data='',
user=None,
encode_as_json=True):
"""Convenience function to create and setup fake requests."""
content_type = 'application/x-www-form-urlencoded'
if data and encode_as_json:
from pootle.core.utils.json import jsonify
content_type = 'application/json'
data = jsonify(data)
request_method = getattr(rf, method.lower())
request = request_method(url, data=data, content_type=content_type)
request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
if user is not None:
request.user = user
return request
def test_view_projects_browse(site_permissions, site_matrix_with_vfolders,
site_matrix_with_announcements,
client, nobody, default):
response = client.get(reverse("pootle-projects-browse"))
assert response.cookies["pootle-language"].value == "projects"
ctx = response.context
request = response.wsgi_request
user_projects = Project.accessible_by_user(request.user)
user_projects = (
Project.objects.for_user(request.user)
.filter(code__in=user_projects))
ob = ProjectSet(user_projects)
items = [
make_project_list_item(project)
for project in ob.children]
items.sort(lambda x, y: locale.strcoll(x['title'], y['title']))
table_fields = [
'name', 'progress', 'total', 'need-translation',
'suggestions', 'critical', 'last-updated', 'activity']
table = {
'id': 'projects',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': items}
assertions = dict(
page="browse",
pootle_path="/projects/",
resource_path="",
resource_path_parts=[],
object=ob,
table=table,
browser_extends="projects/all/base.html",
stats=jsonify(ob.get_stats()),
check_categories=get_qualitycheck_schema(ob),
translation_states=get_translation_states(ob),
url_action_continue=ob.get_translate_url(state='incomplete'),
url_action_fixcritical=ob.get_critical_url(),
url_action_review=ob.get_translate_url(state='suggestions'),
url_action_view_all=ob.get_translate_url(state='all'))
view_context_test(ctx, **assertions)
def test_view_projects_browse(
site_permissions, site_matrix_with_vfolders, site_matrix_with_announcements, client, nobody, default
):
response = client.get(reverse("pootle-projects-browse"))
assert response.cookies["pootle-language"].value == "projects"
ctx = response.context
request = response.wsgi_request
user_projects = Project.accessible_by_user(request.user)
user_projects = Project.objects.for_user(request.user).filter(code__in=user_projects)
ob = ProjectSet(user_projects)
items = [make_project_list_item(project) for project in ob.children]
items.sort(lambda x, y: locale.strcoll(x["title"], y["title"]))
table_fields = [
"name",
"progress",
"total",
"need-translation",
"suggestions",
"critical",
"last-updated",
"activity",
]
table = {"id": "projects", "fields": table_fields, "headings": get_table_headings(table_fields), "items": items}
assertions = dict(
page="browse",
pootle_path="/projects/",
resource_path="",
resource_path_parts=[],
resource_obj=ob,
table=table,
browser_extends="projects/all/base.html",
stats=jsonify(ob.get_stats()),
check_categories=get_qualitycheck_schema(ob),
translation_states=get_translation_states(ob),
url_action_continue=ob.get_translate_url(state="incomplete"),
url_action_fixcritical=ob.get_critical_url(),
url_action_review=ob.get_translate_url(state="suggestions"),
url_action_view_all=ob.get_translate_url(state="all"),
)
view_context_test(ctx, **assertions)
def test_duedate_update(client, request_users, test_name, snapshot_stack,
path):
"""Tests updating existing due dates."""
user = request_users['user']
initial_due_on = aware_datetime(2017, 01, 26, 01, 02, 03)
data = {
'due_on': initial_due_on,
'modified_by': user,
'pootle_path': path,
}
due_date = DueDateFactory.create(**data)
assert due_date.id is not None
url = '/xhr/duedates/%s/' % due_date.id
put_data = {
'due_on': '2017-01-27',
'pootle_path': path,
}
with snapshot_stack.push(
[as_dir(test_name),
as_dir(user.username),
url_name(path)]):
if not user.is_anonymous:
client.force_login(user)
response = client.put(url,
jsonify(put_data),
content_type='application/json')
if response.status_code == 200:
due_date.refresh_from_db()
assert due_date.due_on != initial_due_on
with snapshot_stack.push('status_code') as snapshot:
snapshot.assert_matches(response.status_code)
with snapshot_stack.push('context') as snapshot:
snapshot.assert_matches(response.json())
def test_duedate_update(client, request_users, test_name, snapshot_stack,
path):
"""Tests updating existing due dates."""
user = request_users["user"]
initial_due_on = aware_datetime(2017, 1, 26, 1, 2, 3)
data = {
"due_on": initial_due_on,
"modified_by": user,
"pootle_path": path,
}
due_date = DueDateFactory.create(**data)
assert due_date.id is not None
url = "/xhr/duedates/%s/" % due_date.id
put_data = {
"due_on": "2017-01-27",
"pootle_path": path,
}
with snapshot_stack.push(
[as_dir(test_name),
as_dir(user.username),
url_name(path)]):
if not user.is_anonymous:
client.force_login(user)
response = client.put(url,
jsonify(put_data),
content_type="application/json")
if response.status_code == 200:
due_date.refresh_from_db()
assert due_date.due_on != initial_due_on
with snapshot_stack.push("status_code") as snapshot:
snapshot.assert_matches(response.status_code)
with snapshot_stack.push("context") as snapshot:
snapshot.assert_matches(response.json())
def get_context_data(self, **kwargs):
languages = Language.objects.exclude(code='templates')
language_choices = [(lang.id, unicode(lang)) for lang in languages]
try:
english = Language.objects.get(code='en')
default_language = english.id
except Language.DoesNotExist:
default_language = languages[0].id
return {
'page':
'admin-projects',
'form_choices':
jsonify({
'checkstyle': Project.checker_choices,
'localfiletype': filetype_choices,
'source_language': language_choices,
'treestyle': Project.treestyle_choices,
'defaults': {
'source_language': default_language,
},
}),
}
def test_duedate_post(client, request_users, test_name, snapshot_stack, path):
"""Tests creating new due dates."""
url = '/xhr/duedates/'
user = request_users['user']
post_data = {
'due_on': '2017-01-26',
'pootle_path': path,
}
with snapshot_stack.push(
[as_dir(test_name),
as_dir(user.username),
url_name(path)]):
if not user.is_anonymous:
client.force_login(user)
response = client.post(url,
jsonify(post_data),
content_type='application/json')
with snapshot_stack.push('status_code') as snapshot:
snapshot.assert_matches(response.status_code)
with snapshot_stack.push('context') as snapshot:
snapshot.assert_matches(response.json())
def browse(request, language):
user_tps = language.get_children_for_user(request.user)
items = (make_project_item(tp) for tp in user_tps)
table_fields = ['name', 'progress', 'total', 'need-translation',
'suggestions', 'critical', 'last-updated', 'activity']
ctx, cookie_data = get_sidebar_announcements_context(
request,
(language, ),
)
ctx.update(get_browser_context(request))
ctx.update({
'language': {
'code': language.code,
'name': tr_lang(language.fullname),
},
'table': {
'id': 'language',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': items,
},
'stats': jsonify(request.resource_obj.get_stats_for_user(request.user)),
'browser_extends': 'languages/base.html',
})
response = render(request, 'browser/index.html', ctx)
response.set_cookie('pootle-language', language.code)
if cookie_data:
response.set_cookie(SIDEBAR_COOKIE_NAME, cookie_data)
return response
def test_duedate_post(client, request_users, test_name, snapshot_stack, path):
"""Tests creating new due dates."""
url = "/xhr/duedates/"
user = request_users["user"]
post_data = {
"due_on": "2017-01-26",
"pootle_path": path,
}
with snapshot_stack.push(
[as_dir(test_name),
as_dir(user.username),
url_name(path)]):
if not user.is_anonymous:
client.force_login(user)
response = client.post(url,
jsonify(post_data),
content_type="application/json")
with snapshot_stack.push("status_code") as snapshot:
snapshot.assert_matches(response.status_code)
with snapshot_stack.push("context") as snapshot:
snapshot.assert_matches(response.json())
def test_schema(capfd):
call_command('schema')
out, err = capfd.readouterr()
schema_tool = SchemaTool()
assert jsonify(schema_tool.get_defaults()) in out
def test_schema_tables(capfd):
call_command('schema', '--tables')
out, err = capfd.readouterr()
schema_tool = SchemaTool()
assert jsonify(schema_tool.get_tables()) in out
def test_schema_app_tables(capfd):
call_command('schema', 'app', 'pootle_store', '--tables')
out, err = capfd.readouterr()
schema_tool = SchemaTool('pootle_store')
assert jsonify(schema_tool.get_tables()) in out
def _test_browse_view(project, request, response, kwargs):
cookie_data = json.loads(
unquote(response.cookies[SIDEBAR_COOKIE_NAME].value))
assert cookie_data["foo"] == "bar"
assert "announcements_projects_%s" % project.code in cookie_data
ctx = response.context
kwargs["project_code"] = project.code
resource_path = (
"%(dir_path)s%(filename)s" % kwargs)
project_path = (
"%s/%s"
% (kwargs["project_code"], resource_path))
if not (kwargs["dir_path"] or kwargs["filename"]):
ob = project
elif not kwargs["filename"]:
ob = ProjectResource(
Directory.objects.live().filter(
pootle_path__regex="^/.*/%s$" % project_path),
pootle_path="/projects/%s" % project_path)
else:
ob = ProjectResource(
Store.objects.live().filter(
pootle_path__regex="^/.*/%s$" % project_path),
pootle_path="/projects/%s" % project_path)
item_func = (
make_xlanguage_item
if (kwargs["dir_path"]
or kwargs["filename"])
else make_language_item)
items = [
item_func(item)
for item
in ob.get_children_for_user(request.user)
]
items.sort(lambda x, y: locale.strcoll(x['title'], y['title']))
table_fields = ['name', 'progress', 'total', 'need-translation',
'suggestions', 'critical', 'last-updated', 'activity']
table = {
'id': 'project',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': items}
if request.user.is_superuser or kwargs.get("language_code"):
url_action_continue = ob.get_translate_url(state='incomplete')
url_action_fixcritical = ob.get_critical_url()
url_action_review = ob.get_translate_url(state='suggestions')
url_action_view_all = ob.get_translate_url(state='all')
else:
(url_action_continue,
url_action_fixcritical,
url_action_review,
url_action_view_all) = [None] * 4
assertions = dict(
page="browse",
project=project,
browser_extends="projects/base.html",
pootle_path="/projects/%s" % project_path,
resource_path=resource_path,
resource_path_parts=get_path_parts(resource_path),
url_action_continue=url_action_continue,
url_action_fixcritical=url_action_fixcritical,
url_action_review=url_action_review,
url_action_view_all=url_action_view_all,
translation_states=get_translation_states(ob),
check_categories=get_qualitycheck_schema(ob),
table=table,
stats=jsonify(ob.get_stats()))
sidebar = get_sidebar_announcements_context(
request, (project, ))
for k in ["has_sidebar", "is_sidebar_open", "announcements"]:
assertions[k] = sidebar[0][k]
view_context_test(ctx, **assertions)
def _test_browse_view(tp, request, response, kwargs):
cookie_data = json.loads(
unquote(response.cookies[SIDEBAR_COOKIE_NAME].value))
assert cookie_data["foo"] == "bar"
assert "announcements_projects_%s" % tp.project.code in cookie_data
assert "announcements_%s" % tp.language.code in cookie_data
assert (
"announcements_%s_%s"
% (tp.language.code, tp.project.code)
in cookie_data)
ctx = response.context
kwargs["project_code"] = tp.project.code
kwargs["language_code"] = tp.language.code
resource_path = "%(dir_path)s%(filename)s" % kwargs
pootle_path = "%s%s" % (tp.pootle_path, resource_path)
if not (kwargs["dir_path"] or kwargs.get("filename")):
ob = tp.directory
elif not kwargs.get("filename"):
ob = Directory.objects.get(
pootle_path=pootle_path)
else:
ob = Store.objects.get(
pootle_path=pootle_path)
if not kwargs.get("filename"):
vftis = ob.vf_treeitems.select_related("vfolder")
if not ctx["has_admin_access"]:
vftis = vftis.filter(vfolder__is_public=True)
vfolders = [
make_vfolder_treeitem_dict(vfolder_treeitem)
for vfolder_treeitem
in vftis.order_by('-vfolder__priority')
if (ctx["has_admin_access"]
or vfolder_treeitem.is_visible)]
stats = {"vfolders": {}}
for vfolder_treeitem in vfolders or []:
stats['vfolders'][
vfolder_treeitem['code']] = vfolder_treeitem["stats"]
del vfolder_treeitem["stats"]
if stats["vfolders"]:
stats.update(ob.get_stats())
else:
stats = ob.get_stats()
stats = jsonify(stats)
else:
stats = jsonify(ob.get_stats())
vfolders = None
filters = {}
if vfolders:
filters['sort'] = 'priority'
dirs_with_vfolders = vftis_for_child_dirs(ob).values_list(
"directory__pk", flat=True)
directories = [
make_directory_item(
child,
**(dict(sort="priority")
if child.pk in dirs_with_vfolders
else {}))
for child in ob.get_children()
if isinstance(child, Directory)]
stores = [
make_store_item(child)
for child in ob.get_children()
if isinstance(child, Store)]
if not kwargs.get("filename"):
table_fields = [
'name', 'progress', 'total', 'need-translation',
'suggestions', 'critical', 'last-updated', 'activity']
table = {
'id': 'tp',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': directories + stores}
else:
table = None
assertions = dict(
page="browse",
object=ob,
translation_project=tp,
language=tp.language,
project=tp.project,
has_admin_access=check_permission('administrate', request),
is_store=(kwargs.get("filename") and True or False),
browser_extends="translation_projects/base.html",
pootle_path=pootle_path,
resource_path=resource_path,
resource_path_parts=get_path_parts(resource_path),
translation_states=get_translation_states(ob),
check_categories=get_qualitycheck_schema(ob),
url_action_continue=ob.get_translate_url(
state='incomplete', **filters),
url_action_fixcritical=ob.get_critical_url(**filters),
url_action_review=ob.get_translate_url(
state='suggestions', **filters),
url_action_view_all=ob.get_translate_url(state='all'),
stats=stats,
parent=get_parent(ob))
if table:
assertions["table"] = table
sidebar = get_sidebar_announcements_context(
request, (tp.project, tp.language, tp))
for k in ["has_sidebar", "is_sidebar_open", "announcements"]:
assertions[k] = sidebar[0][k]
view_context_test(ctx, **assertions)
if vfolders:
for vfolder in ctx["vfolders"]["items"]:
assert (vfolder["is_grayed"] and not ctx["has_admin_access"]) is False
assert (
ctx["vfolders"]["items"]
== vfolders)
assert (('display_download' in ctx and ctx['display_download']) ==
(request.user.is_authenticated()
and check_permission('translate', request)))
def overview(request, translation_project, dir_path, filename=None):
project = translation_project.project
language = translation_project.language
directory = request.directory
store = request.store
is_admin = check_permission('administrate', request)
# TODO: cleanup and refactor, retrieve from cache
try:
ann_virtual_path = 'announcements/projects/' + project.code
announcement = StaticPage.objects.live(request.user).get(
virtual_path=ann_virtual_path,
)
except StaticPage.DoesNotExist:
announcement = None
has_announcement = announcement is not None
has_sidebar = has_announcement
is_sidebar_open = True
stored_mtime = None
new_mtime = None
cookie_data = {}
if SIDEBAR_COOKIE_NAME in request.COOKIES:
json_str = unquote(request.COOKIES[SIDEBAR_COOKIE_NAME])
cookie_data = json.loads(json_str)
if 'isOpen' in cookie_data:
is_sidebar_open = cookie_data['isOpen']
if project.code in cookie_data:
stored_mtime = cookie_data[project.code]
if has_announcement:
ann_mtime = dateformat.format(announcement.modified_on, 'U')
if ann_mtime != stored_mtime:
is_sidebar_open = True
new_mtime = ann_mtime
ctx = get_overview_context(request)
# TODO improve plugin logic
if "import_export" in settings.INSTALLED_APPS and request.user.is_authenticated():
from import_export.views import handle_upload_form
ctx.update(handle_upload_form(request))
has_download = (check_permission('translate', request) or
check_permission('suggest', request))
ctx.update({
'display_download': has_download,
})
has_sidebar = True
stats = request.resource_obj.get_stats()
if store is None:
table_fields = ['name', 'progress', 'total', 'need-translation',
'suggestions', 'critical', 'last-updated', 'activity']
ctx.update({
'table': {
'id': 'tp',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'parent': get_parent(directory),
'items': get_children(directory),
}
})
vfolders = get_vfolders(directory)
if len(vfolders) > 0:
table_fields = ['name', 'priority', 'progress', 'total',
'need-translation', 'suggestions', 'critical',
'activity']
ctx.update({
'vfolders': {
'id': 'vfolders',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': get_vfolders(directory, all_vfolders=is_admin),
},
})
#FIXME: set vfolders stats in the resource, don't inject them here.
stats['vfolders'] = VirtualFolder.get_stats_for(
directory.pootle_path,
all_vfolders=is_admin
)
ctx.update({
'translation_project': translation_project,
'project': project,
'language': language,
'stats': jsonify(stats),
'is_admin': is_admin,
'browser_extends': 'translation_projects/base.html',
'announcement': announcement,
'is_sidebar_open': is_sidebar_open,
'has_sidebar': has_sidebar,
})
response = render(request, 'browser/overview.html', ctx)
if new_mtime is not None:
cookie_data[project.code] = new_mtime
cookie_data = quote(json.dumps(cookie_data))
response.set_cookie(SIDEBAR_COOKIE_NAME, cookie_data)
return response
def as_json(self):
"""Returns the user's field-values as a JSON-encoded string."""
return jsonify(model_to_dict(self, exclude=['password']))
def as_json(self):
"""Returns a json describing the submission."""
return jsonify(self.get_submission_info())
def as_json(self):
"""Returns a json describing the submission."""
return jsonify(self.get_submission_info())
def handle(self, **options):
schema_tool = SchemaTool()
if options['tables']:
self.stdout.write(jsonify(schema_tool.get_tables()))
else:
self.stdout.write(jsonify(schema_tool.get_defaults()))
def as_json(self):
"""Returns the user's field-values as a JSON-encoded string."""
return jsonify(model_to_dict(self, exclude=['password']))
def browse(request, translation_project, dir_path, filename=None):
project = translation_project.project
language = translation_project.language
directory = request.directory
store = request.store
is_admin = check_permission('administrate', request)
ctx, cookie_data = get_sidebar_announcements_context(
request,
(
project,
language,
translation_project,
),
)
ctx.update(get_browser_context(request))
# TODO improve plugin logic
if "import_export" in settings.INSTALLED_APPS:
if request.user.is_authenticated():
if check_permission('translate', request):
ctx.update(handle_upload_form(request, project))
ctx.update({'display_download': True, 'has_sidebar': True})
stats = request.resource_obj.get_stats()
if store is None:
table_fields = [
'name', 'progress', 'total', 'need-translation', 'suggestions',
'critical', 'last-updated', 'activity'
]
ctx.update({
'table': {
'id': 'tp',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': get_children(directory),
}
})
if 'virtualfolder' in settings.INSTALLED_APPS:
vfolders = get_vfolders(directory, all_vfolders=is_admin)
if len(vfolders) > 0:
table_fields = [
'name', 'priority', 'progress', 'total',
'need-translation', 'suggestions', 'critical',
'last-updated', 'activity'
]
ctx.update({
'vfolders': {
'id': 'vfolders',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': vfolders,
},
})
# FIXME: set vfolders stats in the resource, don't inject them
# here.
stats['vfolders'] = {}
for vfolder_treeitem in directory.vf_treeitems.iterator():
if request.user.is_superuser or vfolder_treeitem.is_visible:
stats['vfolders'][vfolder_treeitem.code] = \
vfolder_treeitem.get_stats(include_children=False)
ctx.update({
'parent': get_parent(directory if store is None else store),
'translation_project': translation_project,
'project': project,
'language': language,
'stats': jsonify(stats),
'is_admin': is_admin,
'is_store': store is not None,
'browser_extends': 'translation_projects/base.html',
})
response = render(request, 'browser/index.html', ctx)
if cookie_data:
response.set_cookie(SIDEBAR_COOKIE_NAME, cookie_data)
return response
def browse(request, translation_project, dir_path, filename=None):
project = translation_project.project
language = translation_project.language
directory = request.directory
store = request.store
is_admin = check_permission('administrate', request)
ctx, cookie_data = get_sidebar_announcements_context(
request,
(project, language, translation_project, ),
)
ctx.update(get_browser_context(request))
# TODO improve plugin logic
if "import_export" in settings.INSTALLED_APPS:
if request.user.is_authenticated():
if check_permission('translate', request):
ctx.update(handle_upload_form(request, project))
ctx.update({'display_download': True,
'has_sidebar': True})
stats = request.resource_obj.get_stats()
if store is None:
table_fields = ['name', 'progress', 'total', 'need-translation',
'suggestions', 'critical', 'last-updated', 'activity']
ctx.update({
'table': {
'id': 'tp',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': get_children(directory),
}
})
if 'virtualfolder' in settings.INSTALLED_APPS:
vfolders = get_vfolders(directory, all_vfolders=is_admin)
if len(vfolders) > 0:
table_fields = ['name', 'priority', 'progress', 'total',
'need-translation', 'suggestions', 'critical',
'last-updated', 'activity']
ctx.update({
'vfolders': {
'id': 'vfolders',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': vfolders,
},
})
# FIXME: set vfolders stats in the resource, don't inject them
# here.
stats['vfolders'] = {}
for vfolder_treeitem in directory.vf_treeitems.iterator():
if request.user.is_superuser or vfolder_treeitem.is_visible:
stats['vfolders'][vfolder_treeitem.code] = \
vfolder_treeitem.get_stats(include_children=False)
ctx.update({
'parent': get_parent(directory if store is None else store),
'translation_project': translation_project,
'project': project,
'language': language,
'stats': jsonify(stats),
'is_admin': is_admin,
'is_store': store is not None,
'browser_extends': 'translation_projects/base.html',
})
response = render(request, 'browser/index.html', ctx)
if cookie_data:
response.set_cookie(SIDEBAR_COOKIE_NAME, cookie_data)
return response
def _test_browse_view(tp, request, response, kwargs):
cookie_data = json.loads(
unquote(response.cookies[SIDEBAR_COOKIE_NAME].value))
assert cookie_data["foo"] == "bar"
assert "announcements_projects_%s" % tp.project.code in cookie_data
assert "announcements_%s" % tp.language.code in cookie_data
assert ("announcements_%s_%s" % (tp.language.code, tp.project.code)
in cookie_data)
ctx = response.context
kwargs["project_code"] = tp.project.code
kwargs["language_code"] = tp.language.code
resource_path = "%(dir_path)s%(filename)s" % kwargs
pootle_path = "%s%s" % (tp.pootle_path, resource_path)
if not (kwargs["dir_path"] or kwargs.get("filename")):
ob = tp.directory
elif not kwargs.get("filename"):
ob = Directory.objects.get(pootle_path=pootle_path)
else:
ob = Store.objects.get(pootle_path=pootle_path)
if not kwargs.get("filename"):
vftis = ob.vf_treeitems.select_related("vfolder")
if not ctx["is_admin"]:
vftis = vftis.filter(vfolder__is_public=True)
vfolders = [
make_vfolder_treeitem_dict(vfolder_treeitem)
for vfolder_treeitem in vftis.order_by('-vfolder__priority')
if (ctx["is_admin"] or vfolder_treeitem.is_visible)
]
stats = {"vfolders": {}}
for vfolder_treeitem in vfolders or []:
stats['vfolders'][
vfolder_treeitem['code']] = vfolder_treeitem["stats"]
del vfolder_treeitem["stats"]
if stats["vfolders"]:
stats.update(ob.get_stats())
else:
stats = ob.get_stats()
stats = jsonify(stats)
else:
stats = jsonify(ob.get_stats())
vfolders = None
filters = {}
if vfolders:
filters['sort'] = 'priority'
dirs_with_vfolders = vftis_for_child_dirs(ob).values_list("directory__pk",
flat=True)
directories = [
make_directory_item(
child,
**(dict(
sort="priority") if child.pk in dirs_with_vfolders else {}))
for child in ob.get_children() if isinstance(child, Directory)
]
stores = [
make_store_item(child) for child in ob.get_children()
if isinstance(child, Store)
]
if not kwargs.get("filename"):
table_fields = [
'name', 'progress', 'total', 'need-translation', 'suggestions',
'critical', 'last-updated', 'activity'
]
table = {
'id': 'tp',
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': directories + stores
}
else:
table = None
assertions = dict(
page="browse",
object=ob,
translation_project=tp,
language=tp.language,
project=tp.project,
is_admin=check_permission('administrate', request),
is_store=(kwargs.get("filename") and True or False),
browser_extends="translation_projects/base.html",
pootle_path=pootle_path,
resource_path=resource_path,
resource_path_parts=get_path_parts(resource_path),
translation_states=get_translation_states(ob),
check_categories=get_qualitycheck_schema(ob),
url_action_continue=ob.get_translate_url(state='incomplete',
**filters),
url_action_fixcritical=ob.get_critical_url(**filters),
url_action_review=ob.get_translate_url(state='suggestions', **filters),
url_action_view_all=ob.get_translate_url(state='all'),
stats=stats,
parent=get_parent(ob))
if table:
assertions["table"] = table
sidebar = get_sidebar_announcements_context(request,
(tp.project, tp.language, tp))
for k in ["has_sidebar", "is_sidebar_open", "announcements"]:
assertions[k] = sidebar[0][k]
view_context_test(ctx, **assertions)
if vfolders:
for vfolder in ctx["vfolders"]["items"]:
assert (vfolder["is_grayed"] and not ctx["is_admin"]) is False
assert (ctx["vfolders"]["items"] == vfolders)
assert (('display_download' in ctx
and ctx['display_download']) == (request.user.is_authenticated()
and check_permission(
'translate', request)))
def serialize(self, ctx_data):
return jsonify(self.clean(ctx_data), indent=2)
def _test_browse_view(tp, request, response, kwargs):
cookie_data = json.loads(unquote(response.cookies[SIDEBAR_COOKIE_NAME].value))
assert cookie_data["foo"] == "bar"
assert "announcements_projects_%s" % tp.project.code in cookie_data
assert "announcements_%s" % tp.language.code in cookie_data
assert "announcements_%s_%s" % (tp.language.code, tp.project.code) in cookie_data
ctx = response.context
kwargs["project_code"] = tp.project.code
kwargs["language_code"] = tp.language.code
resource_path = "%(dir_path)s%(filename)s" % kwargs
pootle_path = "%s%s" % (tp.pootle_path, resource_path)
if not (kwargs["dir_path"] or kwargs.get("filename")):
ob = tp.directory
elif not kwargs.get("filename"):
ob = Directory.objects.get(pootle_path=pootle_path)
else:
ob = Store.objects.get(pootle_path=pootle_path)
if not kwargs.get("filename"):
vftis = ob.vf_treeitems.select_related("vfolder")
if not ctx["is_admin"]:
vftis = vftis.filter(vfolder__is_public=True)
vfolders = [
make_vfolder_treeitem_dict(vfolder_treeitem)
for vfolder_treeitem in vftis.order_by("-vfolder__priority")
if (ctx["is_admin"] or vfolder_treeitem.is_visible)
]
stats = {"vfolders": {}}
for vfolder_treeitem in vfolders or []:
stats["vfolders"][vfolder_treeitem["code"]] = vfolder_treeitem["stats"]
del vfolder_treeitem["stats"]
if stats["vfolders"]:
stats.update(ob.get_stats())
else:
stats = ob.get_stats()
stats = jsonify(stats)
else:
stats = jsonify(ob.get_stats())
vfolders = None
filters = {}
if vfolders:
filters["sort"] = "priority"
dirs_with_vfolders = vftis_for_child_dirs(ob).values_list("directory__pk", flat=True)
directories = [
make_directory_item(child, **(dict(sort="priority") if child.pk in dirs_with_vfolders else {}))
for child in ob.get_children()
if isinstance(child, Directory)
]
stores = [make_store_item(child) for child in ob.get_children() if isinstance(child, Store)]
if not kwargs.get("filename"):
table_fields = [
"name",
"progress",
"total",
"need-translation",
"suggestions",
"critical",
"last-updated",
"activity",
]
table = {
"id": "tp",
"fields": table_fields,
"headings": get_table_headings(table_fields),
"items": directories + stores,
}
else:
table = None
assertions = dict(
page="browse",
object=ob,
translation_project=tp,
language=tp.language,
project=tp.project,
is_admin=False,
is_store=(kwargs.get("filename") and True or False),
browser_extends="translation_projects/base.html",
pootle_path=pootle_path,
resource_path=resource_path,
resource_path_parts=get_path_parts(resource_path),
translation_states=get_translation_states(ob),
check_categories=get_qualitycheck_schema(ob),
url_action_continue=ob.get_translate_url(state="incomplete", **filters),
url_action_fixcritical=ob.get_critical_url(**filters),
url_action_review=ob.get_translate_url(state="suggestions", **filters),
url_action_view_all=ob.get_translate_url(state="all"),
stats=stats,
parent=get_parent(ob),
)
if table:
assertions["table"] = table
sidebar = get_sidebar_announcements_context(request, (tp.project, tp.language, tp))
for k in ["has_sidebar", "is_sidebar_open", "announcements"]:
assertions[k] = sidebar[0][k]
view_context_test(ctx, **assertions)
if vfolders:
for vfolder in ctx["vfolders"]["items"]:
assert vfolder["is_grayed"] is False
assert ctx["vfolders"]["items"] == vfolders
