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)})