def notes(request, obj_type=None):
"""
Display all repositories or accounts with a note
"""
if obj_type is None:
return redirect(notes, obj_type='repositories')
model = obj_type_from_url(obj_type)
sort_key = request.GET.get('sort_by', '-note')
if model == 'account':
sort = get_account_sort(sort_key, default=None)
per_page = settings.ACCOUNTS_PER_PAGE
else:
sort = get_repository_sort(sort_key, default=None)
per_page = settings.REPOSITORIES_PER_PAGE
if not sort.get('db_sort'):
sort = prepare_sort(sort_key, dict(note='modified'), default='note', default_reverse=True)
all_notes = _get_last_user_notes(request.user, only=model, sort_by=sort['db_sort'])[model]
page = paginate(request, all_notes, per_page)
context = dict(
page = page,
obj_type = obj_type,
sort = dict(
key = sort['key'],
reverse = sort['reverse'],
),
)
return render(request, 'dashboard/notes.html', context)
def followers(request):
"""
Display followers for all accounts of the user
"""
all_followers = Account.for_user_list.filter(following__user=request.user).extra(select=dict(current_user_account_id='core_account_following.to_account_id'))
sort = get_account_sort(request.GET.get('sort_by', None), default=None)
if sort['key']:
all_followers = all_followers.order_by(sort['db_sort'])
following_ids = Account.objects.filter(followers__user=request.user).values_list('id', flat=True)
def get_accounts_dict():
return accounts_dict(request)
page = paginate(request, all_followers, settings.ACCOUNTS_PER_PAGE)
context = dict(
page = page,
sort = dict(
key = sort['key'],
reverse = sort['reverse'],
),
following_ids = following_ids,
accounts = get_accounts_dict,
)
return render(request, 'dashboard/followers.html', context)
def search(request):
query = request.REQUEST.get("q", None)
if query is not None:
results = Quote.objects.filter(quote__icontains=query).order_by("-id")
return render(request, "quotes/search.html", {"results": paginate(request, results), "query": query})
else:
raise Http404
def followers(request):
"""
Display followers for all accounts of the user
"""
all_followers = Account.for_user_list.filter(
following__user=request.user).extra(select=dict(
current_user_account_id='core_account_following.to_account_id'))
sort = get_account_sort(request.GET.get('sort_by', None), default=None)
if sort['key']:
all_followers = all_followers.order_by(sort['db_sort'])
following_ids = Account.objects.filter(
followers__user=request.user).values_list('id', flat=True)
def get_accounts_dict():
return accounts_dict(request)
page = paginate(request, all_followers, settings.ACCOUNTS_PER_PAGE)
context = dict(
page=page,
sort=dict(
key=sort['key'],
reverse=sort['reverse'],
),
following_ids=following_ids,
accounts=get_accounts_dict,
)
return render(request, 'dashboard/followers.html', context)
def search(request):
query = request.REQUEST.get('q', None)
if query is not None:
results = Link.objects.filter(link__icontains=query).order_by('-id')
return render(request, 'links/search.html', {'results': paginate(request, results), 'query': query})
else:
raise Http404
def forks(request, backend, project, repository=None):
"""
Page listing forks of a repository
"""
mode = request.GET.get('mode')
if mode not in ('real_forks', 'same_name',):
mode = 'real_forks'
sort = get_repository_sort(request.GET.get('sort_by', None), default='updated', default_reverse=True)
if mode == 'real_forks':
sorted_forks = Repository.for_list.filter(parent_fork=repository)
else:
sorted_forks = Repository.for_list.filter(name=repository.name).exclude(is_fork=True)
if sort['key']:
sorted_forks = sorted_forks.order_by(sort['db_sort'])
page = paginate(request, sorted_forks, settings.REPOSITORIES_PER_PAGE)
# check sub forks, one query / level
if mode == 'real_forks':
current_forks = page.object_list
while True:
by_id = dict((obj.id, obj) for obj in current_forks)
current_forks = Repository.for_list.filter(parent_fork__in=by_id.keys()).order_by('-official_modified')
if not current_forks:
break
for fork in current_forks:
parent_fork = by_id[fork.parent_fork_id]
if not hasattr(parent_fork, 'direct_forks'):
parent_fork.direct_forks = []
parent_fork.direct_forks.append(fork)
# make one list for each first level fork, to avoid recursion in templates
all_forks = []
def get_all_forks_for(fork, level):
fork.fork_level = level
all_subforks = [fork,]
if hasattr(fork, 'direct_forks'):
for subfork in fork.direct_forks:
all_subforks += get_all_forks_for(subfork, level+1)
delattr(fork, 'direct_forks')
return all_subforks
for fork in page.object_list:
all_forks += get_all_forks_for(fork, 0)
page.object_list = all_forks
context = dict(
forks_mode = mode,
repository = repository,
page = page,
sort = dict(
key = sort['key'],
reverse = sort['reverse'],
),
)
return render(request, 'core/repositories/forks.html', context)
def tags(request, obj_type=None):
"""
Display all tags for the given object type, and a list of tagged objects.
A get parameter "tag" allow to filter the list.
"""
if obj_type is None:
return redirect(tags, obj_type='repositories')
model = obj_type_from_url(obj_type)
def get_tags():
return _get_sorted_user_tags(request.user, only=model)[model]
tag_slug = request.GET.get('tag', None)
params = { 'privatetagged%s__owner' % model: request.user }
if tag_slug:
params['privatetagged%s__tag__slug' % model] = tag_slug
sort_key = request.GET.get('sort_by', 'name')
if model == 'account':
objects = Account.objects.filter(**params)
sort = get_account_sort(sort_key)
per_page = settings.ACCOUNTS_PER_PAGE
else:
objects = Repository.objects.filter(**params).select_related('owner')
sort = get_repository_sort(sort_key)
per_page = settings.REPOSITORIES_PER_PAGE
objects = objects.order_by(sort['db_sort']).distinct()
page = paginate(request, objects, per_page)
context = dict(
tags = get_tags,
obj_type = obj_type,
tag_filter = tag_slug,
page = page,
sort = dict(
key = sort['key'],
reverse = sort['reverse'],
),
)
return render(request, 'dashboard/tags.html', context)
def tags(request, obj_type=None):
"""
Display all tags for the given object type, and a list of tagged objects.
A get parameter "tag" allow to filter the list.
"""
if obj_type is None:
return redirect(tags, obj_type='repositories')
model = obj_type_from_url(obj_type)
def get_tags():
return _get_sorted_user_tags(request.user, only=model)[model]
tag_slug = request.GET.get('tag', None)
params = {'privatetagged%s__owner' % model: request.user}
if tag_slug:
params['privatetagged%s__tag__slug' % model] = tag_slug
sort_key = request.GET.get('sort_by', 'name')
if model == 'account':
objects = Account.objects.filter(**params)
sort = get_account_sort(sort_key)
per_page = settings.ACCOUNTS_PER_PAGE
else:
objects = Repository.objects.filter(**params).select_related('owner')
sort = get_repository_sort(sort_key)
per_page = settings.REPOSITORIES_PER_PAGE
objects = objects.order_by(sort['db_sort']).distinct()
page = paginate(request, objects, per_page)
context = dict(
tags=get_tags,
obj_type=obj_type,
tag_filter=tag_slug,
page=page,
sort=dict(
key=sort['key'],
reverse=sort['reverse'],
),
)
return render(request, 'dashboard/tags.html', context)
def following(request, backend, slug, account=None):
"""
Page listing accounts followed by an account
"""
sort = get_account_sort(request.GET.get('sort_by', None), default=None)
sorted_following = Account.for_list.filter(followers=account)
if sort['key']:
sorted_following = sorted_following.order_by(sort['db_sort'])
page = paginate(request, sorted_following, settings.ACCOUNTS_PER_PAGE)
context = dict(
account = account,
page = page,
sort = dict(
key = sort['key'],
reverse = sort['reverse'],
),
)
return render(request, 'core/accounts/following.html', context)
def contributors(request, backend, project, repository=None):
"""
Page listing users contributing to a repository
"""
sort = get_account_sort(request.GET.get('sort_by', None), default=None)
sorted_contributors = Account.for_list.filter(contributing=repository)
if sort['key']:
sorted_contributors = sorted_contributors.order_by(sort['db_sort'])
page = paginate(request, sorted_contributors, settings.ACCOUNTS_PER_PAGE)
context = dict(
repository = repository,
page = page,
sort = dict(
key = sort['key'],
reverse = sort['reverse'],
),
)
return render(request, 'core/repositories/contributors.html', context)
def notes(request, obj_type=None):
"""
Display all repositories or accounts with a note
"""
if obj_type is None:
return redirect(notes, obj_type='repositories')
model = obj_type_from_url(obj_type)
sort_key = request.GET.get('sort_by', '-note')
if model == 'account':
sort = get_account_sort(sort_key, default=None)
per_page = settings.ACCOUNTS_PER_PAGE
else:
sort = get_repository_sort(sort_key, default=None)
per_page = settings.REPOSITORIES_PER_PAGE
if not sort.get('db_sort'):
sort = prepare_sort(sort_key,
dict(note='modified'),
default='note',
default_reverse=True)
all_notes = _get_last_user_notes(request.user,
only=model,
sort_by=sort['db_sort'])[model]
page = paginate(request, all_notes, per_page)
context = dict(
page=page,
obj_type=obj_type,
sort=dict(
key=sort['key'],
reverse=sort['reverse'],
),
)
return render(request, 'dashboard/notes.html', context)
def _filter_repositories(request, account, queryset):
"""
Helper doing all sort/query stuff about repositories, for listing
repositories owned/followed or contributed by an account,
"""
sort_key = request.GET.get('sort_by', 'name')
repository_supports_owner = account.get_backend().supports('repository_owner')
repository_supports_parent_fork = account.get_backend().supports('repository_parent_fork')
sort = get_repository_sort(sort_key, repository_supports_owner)
sorted_repositories = queryset.order_by(sort['db_sort'])
if repository_supports_owner:
owner_only = request.GET.get('owner-only', False) == 'y'
else:
owner_only = False
if owner_only:
sorted_repositories = sorted_repositories.filter(owner=account)
if repository_supports_parent_fork:
hide_forks = request.GET.get('hide-forks', False) == 'y'
else:
hide_forks = False
if hide_forks:
sorted_repositories = sorted_repositories.exclude(is_fork=True)
query = request.GET.get('q')
if query:
keywords = parse_keywords(query)
search_queryset = make_query(RepositorySearchView.search_fields, keywords)
search_queryset = search_queryset.models(RepositorySearchView.model)
if owner_only:
search_queryset = search_queryset.filter(owner_id=account.id)
if hide_forks:
search_queryset = search_queryset.exclude(is_fork=True)
# It's certainly not the best way to do it but.... :(
sorted_ids = [r.id for r in sorted_repositories]
if sorted_ids:
search_queryset = search_queryset.filter(django_id__in=sorted_ids)
found_ids = [int(r.pk) for r in search_queryset]
sorted_repositories = [r for r in sorted_repositories if r.id in found_ids]
distinct = request.GET.get('distinct', False) == 'y'
if distinct and not owner_only:
# try to keep one entry for each slug
uniq = []
slugs = {}
for repository in sorted_repositories:
if repository.slug in slugs:
slugs[repository.slug].append(repository)
continue
slugs[repository.slug] = []
uniq.append(repository)
for repository in uniq:
repository.distinct_others = slugs[repository.slug]
# try to keep the first non-fork for each one
sorted_repositories = []
sort_lambda = lambda r:r.official_created
for repository in uniq:
if not repository.distinct_others or repository.owner_id == account.id:
good_repository = repository
else:
important_ones = [r for r in repository.distinct_others if not r.is_fork]
owned = [r for r in important_ones if r.owner_id == account.id]
if owned:
good_repository = owned[0] # only one possible
else:
if important_ones:
if not repository.is_fork:
important_ones + [repository,]
else:
important_ones = repository.distinct_others + [repository,]
good_repository = sorted(important_ones, key=sort_lambda)[0]
if good_repository != repository:
good_repository.distinct_others = [r for r in repository.distinct_others + [repository,] if r != good_repository]
delattr(repository, 'distinct_others')
if hasattr(good_repository, 'distinct_others'):
good_repository.distinct_others = sorted(good_repository.distinct_others, key=sort_lambda)
sorted_repositories.append(good_repository)
page = paginate(request, sorted_repositories, settings.REPOSITORIES_PER_PAGE)
return dict(
account = account,
page = page,
sort = dict(
key = sort['key'],
reverse = sort['reverse'],
),
owner_only = 'y' if owner_only else False,
hide_forks = 'y' if hide_forks else False,
distinct = 'y' if distinct else False,
query = query or "",
)
def _filter_repositories(request, param, extra):
"""
Helper doing all sort/query stuff about repositories, for listing
repositories owned/followed or contributed by the user
"""
params = {param: request.user}
owner_only = request.GET.get('owner-only', False) == 'y'
if owner_only:
params['owner__user'] = request.user
all_repositories = Repository.for_user_list.filter(**params).extra(select=dict(current_user_account_id=extra))
hide_forks = request.GET.get('hide-forks', False) == 'y'
if hide_forks:
all_repositories = all_repositories.exclude(is_fork=True)
sort = get_repository_sort(request.GET.get('sort_by', None))
if sort['key']:
all_repositories = all_repositories.order_by(sort['db_sort'])
accounts = accounts_dict(request)
query = request.GET.get('q')
if query:
keywords = parse_keywords(query)
search_queryset = make_query(RepositorySearchView.search_fields, keywords)
search_queryset = search_queryset.models(RepositorySearchView.model)
if owner_only:
search_queryset = search_queryset.filter(owner_id__in=accounts.keys())
if hide_forks:
search_queryset = search_queryset.exclude(is_fork=True)
# It's certainly not the best way to do it but.... :(
sorted_ids = [r.id for r in all_repositories]
if sorted_ids:
search_queryset = search_queryset.filter(django_id__in=sorted_ids)
found_ids = [int(r.pk) for r in search_queryset]
all_repositories = [r for r in all_repositories if r.id in found_ids]
distinct = request.GET.get('distinct', False) == 'y'
if distinct:
# try to keep one entry for each backend/slug
uniq = []
slugs = {}
for repository in all_repositories:
slug = '%s:%s' % (repository.backend, repository.slug)
if slug in slugs:
slugs[slug].append(repository)
continue
slugs[slug] = []
uniq.append(repository)
for repository in uniq:
slug = '%s:%s' % (repository.backend, repository.slug)
repository.distinct_others = slugs[slug]
# try to keep the first non-fork for each one
all_repositories = []
sort_lambda = lambda r:r.official_created
for repository in uniq:
if not repository.distinct_others or repository.owner_id in accounts:
good_repository = repository
else:
important_ones = [r for r in repository.distinct_others if not r.is_fork]
owned = [r for r in important_ones if r.owner_id in accounts]
if owned:
good_repository = owned[0] # all are from the owner, take one
else:
if important_ones:
if not repository.is_fork:
important_ones + [repository,]
else:
important_ones = repository.distinct_others + [repository,]
good_repository = sorted(important_ones, key=sort_lambda)[0]
if good_repository != repository:
good_repository.distinct_others = [r for r in repository.distinct_others + [repository,] if r != good_repository]
delattr(repository, 'distinct_others')
if hasattr(good_repository, 'distinct_others'):
good_repository.distinct_others = sorted(good_repository.distinct_others, key=sort_lambda)
good_repository.current_user_account_id_list = set((good_repository.current_user_account_id,))
if hasattr(good_repository, 'distinct_others'):
for other_rep in good_repository.distinct_others:
good_repository.current_user_account_id_list.add(other_rep.current_user_account_id)
all_repositories.append(good_repository)
page = paginate(request, all_repositories, settings.REPOSITORIES_PER_PAGE)
context = dict(
all_repositories = all_repositories,
page = page,
sort = dict(
key = sort['key'],
reverse = sort['reverse'],
),
accounts = accounts,
owner_only = 'y' if owner_only else False,
hide_forks = 'y' if hide_forks else False,
distinct = 'y' if distinct else False,
query = query or "",
)
return context
def _filter_repositories(request, param, extra):
"""
Helper doing all sort/query stuff about repositories, for listing
repositories owned/followed or contributed by the user
"""
params = {param: request.user}
owner_only = request.GET.get('owner-only', False) == 'y'
if owner_only:
params['owner__user'] = request.user
all_repositories = Repository.for_user_list.filter(**params).extra(
select=dict(current_user_account_id=extra))
hide_forks = request.GET.get('hide-forks', False) == 'y'
if hide_forks:
all_repositories = all_repositories.exclude(is_fork=True)
sort = get_repository_sort(request.GET.get('sort_by', None))
if sort['key']:
all_repositories = all_repositories.order_by(sort['db_sort'])
accounts = accounts_dict(request)
query = request.GET.get('q')
if query:
keywords = parse_keywords(query)
search_queryset = make_query(RepositorySearchView.search_fields,
keywords)
search_queryset = search_queryset.models(RepositorySearchView.model)
if owner_only:
search_queryset = search_queryset.filter(
owner_id__in=accounts.keys())
if hide_forks:
search_queryset = search_queryset.exclude(is_fork=True)
# It's certainly not the best way to do it but.... :(
sorted_ids = [r.id for r in all_repositories]
if sorted_ids:
search_queryset = search_queryset.filter(django_id__in=sorted_ids)
found_ids = [int(r.pk) for r in search_queryset]
all_repositories = [
r for r in all_repositories if r.id in found_ids
]
distinct = request.GET.get('distinct', False) == 'y'
if distinct:
# try to keep one entry for each backend/slug
uniq = []
slugs = {}
for repository in all_repositories:
slug = '%s:%s' % (repository.backend, repository.slug)
if slug in slugs:
slugs[slug].append(repository)
continue
slugs[slug] = []
uniq.append(repository)
for repository in uniq:
slug = '%s:%s' % (repository.backend, repository.slug)
repository.distinct_others = slugs[slug]
# try to keep the first non-fork for each one
all_repositories = []
sort_lambda = lambda r: r.official_created
for repository in uniq:
if not repository.distinct_others or repository.owner_id in accounts:
good_repository = repository
else:
important_ones = [
r for r in repository.distinct_others if not r.is_fork
]
owned = [r for r in important_ones if r.owner_id in accounts]
if owned:
good_repository = owned[
0] # all are from the owner, take one
else:
if important_ones:
if not repository.is_fork:
important_ones + [
repository,
]
else:
important_ones = repository.distinct_others + [
repository,
]
good_repository = sorted(important_ones,
key=sort_lambda)[0]
if good_repository != repository:
good_repository.distinct_others = [
r for r in repository.distinct_others + [
repository,
] if r != good_repository
]
delattr(repository, 'distinct_others')
if hasattr(good_repository, 'distinct_others'):
good_repository.distinct_others = sorted(
good_repository.distinct_others, key=sort_lambda)
good_repository.current_user_account_id_list = set(
(good_repository.current_user_account_id, ))
if hasattr(good_repository, 'distinct_others'):
for other_rep in good_repository.distinct_others:
good_repository.current_user_account_id_list.add(
other_rep.current_user_account_id)
all_repositories.append(good_repository)
page = paginate(request, all_repositories, settings.REPOSITORIES_PER_PAGE)
context = dict(
all_repositories=all_repositories,
page=page,
sort=dict(
key=sort['key'],
reverse=sort['reverse'],
),
accounts=accounts,
owner_only='y' if owner_only else False,
hide_forks='y' if hide_forks else False,
distinct='y' if distinct else False,
query=query or "",
)
return context
def list(request):
quotes = Quote.objects.all().order_by("-id")
return render(request, "quotes/list.html", {"quotes": paginate(request, quotes)})
def list(request):
links = Link.objects.all().order_by('-id')
return render(request, 'links/list.html', {'links': paginate(request, links, per_page=50)})
