euscan-ng/euscanwww/djeuscan/views.py
volpino d8de359256 euscanwww: Added feeds help page
Signed-off-by: volpino <fox91@anche.no>
2012-08-14 15:32:54 +02:00

610 lines
17 KiB
Python

""" Views """
import inspect
from annoying.decorators import render_to, ajax_request
from django.http import Http404
from django.shortcuts import get_object_or_404
from django.contrib.auth.decorators import login_required
from django.views.decorators.http import require_POST
from djeuscan.helpers import version_key, packages_from_names, get_profile, \
get_account_categories, get_account_herds, get_account_maintainers, \
get_user_fav_infos
from djeuscan.feeds import UserFeed
from djeuscan.models import Version, Package, Herd, Maintainer, EuscanResult, \
VersionLog, RefreshPackageQuery, ProblemReport, Category, Overlay
from djeuscan.forms import WorldForm, PackagesForm, ProblemReportForm, \
PreferencesForm
from djeuscan.tasks import admin_tasks
from djeuscan import charts
@render_to('euscan/index.html')
def index(request):
context = {
'n_packaged': Package.objects.n_packaged(),
'n_overlay': Package.objects.n_overlay(),
'n_versions': Package.objects.n_versions(),
'n_upstream': Package.objects.n_upstream(),
'n_packages': Package.objects.count(),
'n_herds': Herd.objects.count(),
'n_maintainers': Maintainer.objects.count(),
}
try:
context['last_scan'] = EuscanResult.objects.latest().datetime
except EuscanResult.DoesNotExist:
context['last_scan'] = None
return context
@render_to('euscan/logs.html')
def logs(request):
return {}
@render_to('euscan/categories.html')
def categories(request):
try:
last_scan = EuscanResult.objects.latest().datetime
except EuscanResult.DoesNotExist:
last_scan = None
return {'categories': Package.objects.categories(), 'last_scan': last_scan}
@render_to('euscan/category.html')
def category(request, category):
packages = Package.objects.for_category(category, last_versions=True)
if not packages:
raise Http404
try:
last_scan = \
EuscanResult.objects.for_category(category).latest().datetime
except EuscanResult.DoesNotExist:
last_scan = None
favourited = False
if request.user.is_authenticated():
try:
category = Category.objects.get(name=category)
favourited = category in get_profile(request.user).categories.all()
except Category.DoesNotExist:
pass
return {'category': category, 'packages': packages, 'last_scan': last_scan,
'favourited': favourited}
@render_to('euscan/herds.html')
def herds(request):
herds = Package.objects.herds()
try:
last_scan = EuscanResult.objects.latest().datetime
except EuscanResult.DoesNotExist:
last_scan = None
return {'herds': herds, 'last_scan': last_scan}
@render_to('euscan/herd.html')
def herd(request, herd):
herd = get_object_or_404(Herd, herd=herd)
packages = Package.objects.for_herd(herd, last_versions=True)
try:
last_scan = EuscanResult.objects.for_herd(herd).latest().datetime
except EuscanResult.DoesNotExist:
last_scan = None
favourited = False
if request.user.is_authenticated():
if herd in get_profile(request.user).herds.all():
favourited = True
return {'herd': herd, 'packages': packages, "last_scan": last_scan,
'favourited': favourited}
@render_to('euscan/maintainers.html')
def maintainers(request):
maintainers = Package.objects.maintainers()
try:
last_scan = EuscanResult.objects.latest().datetime
except EuscanResult.DoesNotExist:
last_scan = None
return {'maintainers': maintainers, 'last_scan': last_scan}
@render_to('euscan/maintainer.html')
def maintainer(request, maintainer_id):
maintainer = get_object_or_404(Maintainer, pk=maintainer_id)
packages = Package.objects.for_maintainer(maintainer, last_versions=True)
try:
last_scan = \
EuscanResult.objects.for_maintainer(maintainer).latest().datetime
except EuscanResult.DoesNotExist:
last_scan = None
favourited = False
if request.user.is_authenticated():
if maintainer in get_profile(request.user).maintainers.all():
favourited = True
return {'maintainer': maintainer, 'packages': packages,
'last_scan': last_scan, 'favourited': favourited}
@render_to('euscan/overlays.html')
def overlays(request):
overlays = Package.objects.overlays()
try:
last_scan = EuscanResult.objects.latest().datetime
except EuscanResult.DoesNotExist:
last_scan = None
return {'overlays': overlays, 'last_scan': last_scan}
@render_to('euscan/overlay.html')
def overlay(request, overlay):
packages = Package.objects.for_overlay(overlay)
if not packages:
raise Http404
try:
last_scan = EuscanResult.objects.latest().datetime
except EuscanResult.DoesNotExist:
last_scan = None
favourited = False
if request.user.is_authenticated():
try:
overlay = Overlay.objects.get(name=overlay)
favourited = overlay in get_profile(request.user).overlays.all()
except Overlay.DoesNotExist:
pass
return {'overlay': overlay, 'packages': packages, 'last_scan': last_scan,
'favourited': favourited}
@render_to('euscan/package.html')
def package(request, category, package):
package = get_object_or_404(Package, category=category, name=package)
packaged = Version.objects.filter(package=package, packaged=True)
upstream = Version.objects.filter(package=package, packaged=False)
packaged = sorted(packaged, key=version_key)
upstream = sorted(upstream, key=version_key)
log = EuscanResult.objects.filter(package=package).\
order_by('-datetime')[:1]
log = log[0] if log else None
vlog = VersionLog.objects.for_package(package, order=True)
try:
last_scan = EuscanResult.objects.for_package(package).latest().datetime
except EuscanResult.DoesNotExist:
last_scan = None
favourited = False
if request.user.is_authenticated():
if package in get_profile(request.user).packages.all():
favourited = True
try:
refresh_query = RefreshPackageQuery.objects.get(package=package)
except RefreshPackageQuery.DoesNotExist:
refresh_requested = False
refresh_pos = None
else:
refresh_requested = request.user in refresh_query.users.all()
refresh_pos = refresh_query.position
return {
'package': package,
'packaged': packaged,
'upstream': upstream,
'vlog': vlog,
'log': log,
'msg': log.messages if log else "",
'last_scan': last_scan,
'favourited': favourited,
'refresh_requested': refresh_requested,
'refresh_pos': refresh_pos,
}
@login_required
@render_to('euscan/problem.html')
def problem(request, category, package):
package = get_object_or_404(Package, category=category, name=package)
packaged = Version.objects.filter(package=package, packaged=True)
upstream = Version.objects.filter(package=package, packaged=False)
log = EuscanResult.objects.filter(package=package).\
order_by('-datetime')[:1]
log = log[0] if log else None
thanks_for_reporting = False
if request.method == "POST":
form = ProblemReportForm(package, request.POST)
if form.is_valid():
ProblemReport(
package=package,
version=form.cleaned_data["version"],
subject=form.cleaned_data["subject"],
message=form.cleaned_data["message"],
).save()
thanks_for_reporting = True
else:
form = ProblemReportForm(package)
return {
'form': form,
'thanks_for_reporting': thanks_for_reporting,
'package': package,
'packaged': packaged,
'upstream': upstream,
'msg': log.messages if log else "",
}
@render_to('euscan/world.html')
def world(request):
world_form = WorldForm()
packages_form = PackagesForm()
return {
'world_form': world_form,
'packages_form': packages_form
}
@render_to('euscan/world_scan.html')
def world_scan(request):
if 'world' in request.FILES:
data = request.FILES['world'].read()
elif 'packages' in request.POST:
data = request.POST['packages']
else:
data = ""
packages = packages_from_names(data)
packages_ids = [p.pk for p in packages]
favourited = False
if request.user.is_authenticated():
profile = get_profile(request.user)
if len(packages) == len(profile.packages.filter(id__in=packages_ids)):
favourited = True
return {
'packages': packages,
'packages_ids': packages_ids,
'favourited': favourited
}
@render_to("euscan/about.html")
def about(request):
return {}
@render_to("euscan/api.html")
def api(request):
return {}
@render_to("euscan/feeds.html")
def feeds(request):
return {}
@render_to("euscan/statistics.html")
def statistics(request):
return {}
def chart(request, **kwargs):
from django.views.static import serve
chart = kwargs['chart'] if 'chart' in kwargs else None
if 'maintainer_id' in kwargs:
kwargs['maintainer'] = get_object_or_404(
Maintainer,
id=kwargs['maintainer_id']
)
if 'herd' in kwargs:
kwargs['herd'] = get_object_or_404(Herd, herd=kwargs['herd'])
for kw in ('-small', '-weekly', '-monthly', '-yearly'):
if chart.endswith(kw):
if kw in ('-weekly', '-monthly', '-yearly'):
kwargs['period'] = kw
kwargs[kw] = True
chart = chart[:-len(kw)]
if chart == 'pie-packages':
path = charts.pie_packages(**kwargs)
elif chart == 'pie-versions':
path = charts.pie_versions(**kwargs)
elif chart == 'packages':
path = charts.packages(**kwargs)
elif chart == 'versions':
path = charts.versions(**kwargs)
else:
raise Http404
return serve(request, path, document_root=charts.CHARTS_ROOT)
def chart_maintainer(request, **kwargs):
return chart(request, **kwargs)
def chart_herd(request, **kwargs):
return chart(request, **kwargs)
def chart_category(request, **kwargs):
return chart(request, **kwargs)
@ajax_request
def registered_tasks(request):
data = {}
for task in admin_tasks:
argspec = inspect.getargspec(task.run)
data[task.name] = {
"args": argspec.args,
"defaults": argspec.defaults,
"default_types": None
}
if argspec.defaults is not None:
data[task.name].update({
"defaults_types": [type(x).__name__ for x in argspec.defaults]
})
return {"tasks": data}
@login_required
@require_POST
@ajax_request
def refresh_package(request, category, package):
pkg = get_object_or_404(Package, category=category, name=package)
obj, created = RefreshPackageQuery.objects.get_or_create(package=pkg)
if request.user in \
RefreshPackageQuery.objects.get(package=pkg).users.all():
return {"result": "failure"}
obj.users.add(request.user)
if not created:
obj.priority += 1
obj.save()
if created:
from djeuscan.tasks import consume_refresh_queue
consume_refresh_queue.delay()
return {"result": "success", "position": obj.position}
@login_required
@render_to('euscan/accounts/index.html')
def accounts_index(request):
user = request.user
infos = get_user_fav_infos(user)
infos['vlog'] = UserFeed().items({'user': user, 'options': {}})
return infos
@login_required
@render_to('euscan/accounts/preferences.html')
def accounts_preferences(request):
user = request.user
prof = get_profile(user)
updated = False
if request.method == "POST":
form = PreferencesForm(request.POST)
if form.is_valid():
user.first_name = form.cleaned_data["first_name"]
user.last_name = form.cleaned_data["last_name"]
user.email = form.cleaned_data["email"]
user.save(force_update=True)
prof.feed_upstream_info = form.cleaned_data["feed_upstream_info"]
prof.feed_portage_info = form.cleaned_data["feed_portage_info"]
prof.feed_show_adds = form.cleaned_data["feed_show_adds"]
prof.feed_show_removals = form.cleaned_data["feed_show_removals"]
prof.feed_ignore_pre = form.cleaned_data["feed_ignore_pre"]
prof.feed_ignore_pre_if_stable = \
form.cleaned_data["feed_ignore_pre_if_stable"]
prof.email_activated = form.cleaned_data["email_activated"]
prof.email_every = form.cleaned_data["email_every"]
prof.email_ignore_pre = form.cleaned_data["email_ignore_pre"]
prof.email_ignore_pre_if_stable = \
form.cleaned_data["email_ignore_pre_if_stable"]
prof.save(force_update=True)
updated = True
else:
initial_data = {
"first_name": user.first_name,
"last_name": user.last_name,
"email": user.email,
"feed_upstream_info": prof.feed_upstream_info,
"feed_portage_info": prof.feed_portage_info,
"feed_show_adds": prof.feed_show_adds,
"feed_show_removals": prof.feed_show_removals,
"feed_ignore_pre": prof.feed_ignore_pre,
"feed_ignore_pre_if_stable": prof.feed_ignore_pre_if_stable,
"email_activated": prof.email_activated,
"email_every": prof.email_every,
"email_ignore_pre": prof.email_ignore_pre,
"email_ignore_pre_if_stable": prof.email_ignore_pre_if_stable,
}
form = PreferencesForm(initial_data)
return {"form": form, "updated": updated}
@login_required
@render_to('euscan/accounts/categories.html')
def accounts_categories(request):
return {"categories": get_account_categories(request.user)}
@login_required
@render_to('euscan/accounts/herds.html')
def accounts_herds(request):
return {"herds": get_account_herds(request.user)}
@login_required
@render_to('euscan/accounts/maintainers.html')
def accounts_maintainers(request):
return {"maintainers": get_account_maintainers(request.user)}
@login_required
@render_to('euscan/accounts/packages.html')
def accounts_packages(request):
return {"packages": get_profile(request.user).packages.all()}
@login_required
@render_to('euscan/accounts/overlays.html')
def accounts_overlays(request):
overlays = [obj.name for obj in get_profile(request.user).overlays.all()]
return {"overlays": overlays}
@login_required
@require_POST
@ajax_request
def favourite_package(request, category, package):
obj = get_object_or_404(Package, category=category, name=package)
get_profile(request.user).packages.add(obj)
return {"success": True}
@login_required
@require_POST
@ajax_request
def unfavourite_package(request, category, package):
package = get_object_or_404(Package, category=category, name=package)
get_profile(request.user).packages.remove(package)
return {"success": True}
@login_required
@require_POST
@ajax_request
def favourite_herd(request, herd):
obj = get_object_or_404(Herd, herd=herd)
get_profile(request.user).herds.add(obj)
return {"success": True}
@login_required
@require_POST
@ajax_request
def unfavourite_herd(request, herd):
herd = get_object_or_404(Herd, herd=herd)
get_profile(request.user).herds.remove(herd)
return {"success": True}
@login_required
@require_POST
@ajax_request
def favourite_maintainer(request, maintainer_id):
obj = get_object_or_404(Maintainer, pk=maintainer_id)
get_profile(request.user).maintainers.add(obj)
return {"success": True}
@login_required
@require_POST
@ajax_request
def unfavourite_maintainer(request, maintainer_id):
maintainer = get_object_or_404(Maintainer, pk=maintainer_id)
get_profile(request.user).maintainers.remove(maintainer)
return {"success": True}
@login_required
@require_POST
@ajax_request
def favourite_category(request, category):
obj = Category.objects.get(name=category)
get_profile(request.user).categories.add(obj)
return {"success": True}
@login_required
@require_POST
@ajax_request
def unfavourite_category(request, category):
obj = Category.objects.get(name=category)
get_profile(request.user).categories.remove(obj)
return {"success": True}
@login_required
@require_POST
@ajax_request
def favourite_overlay(request, overlay):
obj = Overlay.objects.get(name=overlay)
get_profile(request.user).overlays.add(obj)
return {"success": True}
@login_required
@require_POST
@ajax_request
def unfavourite_overlay(request, overlay):
obj = Overlay.objects.get(name=overlay)
get_profile(request.user).overlays.remove(obj)
return {"success": True}
@login_required
@require_POST
@ajax_request
def favourite_world(request):
if not "packages[]" in request.POST:
return {"success": False}
packages = request.POST.getlist("packages[]")
objs = Package.objects.filter(id__in=packages)
get_profile(request.user).packages.add(*objs)
return {"success": True}
@login_required
@require_POST
@ajax_request
def unfavourite_world(request):
if not "packages[]" in request.POST:
return {"success": False}
packages = request.POST.getlist("packages[]")
objs = Package.objects.filter(id__in=packages)
get_profile(request.user).packages.remove(*objs)
return {"success": True}