def group_add_edit(request, url=None):
    """
    Add or edit a group.  (If a url is passed in, we're editing.)
    """

    profile = request.user.userprofile
    if url:
        # Get the group to edit
        group = get_object_or_404(Group, url=url)
        # Only a group curator or an admin is allowed to edit a group
        is_curator = profile == group.curator
        if not (is_curator or request.user.is_superuser):
            messages.error(request, _('You must be a curator or an admin to edit a group'))
            return redirect(reverse('groups:show_group', args=[group.url]))
    else:
        group = Group(curator=profile)

    form_class = SuperuserGroupForm if request.user.is_superuser else GroupForm

    form = form_class(request.POST or None, instance=group)
    if form.is_valid():
        group = form.save()
        # Ensure curator is in the group when it's created
        if profile == group.curator and not group.has_member(profile):
            group.add_member(profile)
        return redirect(reverse('groups:show_group', args=[group.url]))

    context = {
        'form': form,
        'creating': url is None,
        'group': group if url else None,
    }
    return render(request, 'groups/add_edit.html', context)

def search(request):
    num_pages = 0
    limit = None
    people = []
    show_pagination = False
    form = forms.SearchForm(request.GET)
    groups = None
    curated_groups = None

    if form.is_valid():
        query = form.cleaned_data.get('q', u'')
        limit = form.cleaned_data['limit']
        include_non_vouched = form.cleaned_data['include_non_vouched']
        page = request.GET.get('page', 1)
        curated_groups = Group.get_curated()
        public = not (request.user.is_authenticated()
                      and request.user.userprofile.is_vouched)

        profiles = UserProfile.search(query, public=public,
                                      include_non_vouched=include_non_vouched)
        if not public:
            groups = Group.search(query)

        paginator = Paginator(profiles, limit)

        try:
            people = paginator.page(page)
        except PageNotAnInteger:
            people = paginator.page(1)
        except EmptyPage:
            people = paginator.page(paginator.num_pages)

        if profiles.count() == 1 and not groups:
            return redirect('phonebook:profile_view', people[0].user.username)

        if paginator.count > forms.PAGINATION_LIMIT:
            show_pagination = True
            num_pages = len(people.paginator.page_range)

    d = dict(people=people,
             search_form=form,
             limit=limit,
             show_pagination=show_pagination,
             num_pages=num_pages,
             groups=groups,
             curated_groups=curated_groups)

    if request.is_ajax():
        return render(request, 'search_ajax.html', d)

    return render(request, 'phonebook/search.html', d)

def betasearch(request):
    """This view is for researching new search and data filtering
    options. It will eventually replace the 'search' view.

    This view is behind the 'betasearch' waffle flag.
    """
    limit = None
    people = []
    show_pagination = False
    form = forms.SearchForm(request.GET)
    groups = None
    functional_areas = None

    if form.is_valid():
        query = form.cleaned_data.get('q', u'')
        limit = form.cleaned_data['limit']
        include_non_vouched = form.cleaned_data['include_non_vouched']
        page = request.GET.get('page', 1)
        functional_areas = Group.get_functional_areas()
        public = not (request.user.is_authenticated()
                      and request.user.userprofile.is_vouched)

        profiles = UserProfile.search(query, public=public,
                                      include_non_vouched=include_non_vouched)
        if not public:
            groups = Group.search(query)

        paginator = Paginator(profiles, limit)

        try:
            people = paginator.page(page)
        except PageNotAnInteger:
            people = paginator.page(1)
        except EmptyPage:
            people = paginator.page(paginator.num_pages)

        if profiles.count() == 1 and not groups:
            return redirect('phonebook:profile_view', people[0].user.username)

        show_pagination = paginator.count > settings.ITEMS_PER_PAGE

    d = dict(people=people,
             search_form=form,
             limit=limit,
             show_pagination=show_pagination,
             groups=groups,
             functional_areas=functional_areas)

    return render(request, 'phonebook/betasearch.html', d)

 def test_search_distict_results(self):
     group_1 = GroupFactory.create(name='automation', visible=True)
     GroupAliasFactory.create(alias=group_1, name='automation development')
     GroupAliasFactory.create(alias=group_1, name='automation services')
     results = Group.search('automation')
     eq_(len(results), 1)
     eq_(results[0], group_1)

def index_groups(request):
    """Lists all public groups (in use) on Mozillians."""
    # Omit functional areas, invisible groups, and groups with
    # no vouched members
    query = Group.get_non_functional_areas(members__is_vouched=True)
    template = 'groups/index_groups.html'
    return _list_groups(request, template, query)

def search(request):
    limit = None
    people = []
    show_pagination = False
    form = forms.SearchForm(request.GET)
    groups = None
    curated_groups = None

    if form.is_valid():
        query = form.cleaned_data.get("q", u"")
        limit = form.cleaned_data["limit"]
        include_non_vouched = form.cleaned_data["include_non_vouched"]
        page = request.GET.get("page", 1)
        curated_groups = Group.get_curated()
        public = not (request.user.is_authenticated() and request.user.userprofile.is_vouched)

        profiles = UserProfile.search(query, public=public, include_non_vouched=include_non_vouched)
        if not public:
            groups = Group.search(query)

        paginator = Paginator(profiles, limit)

        try:
            people = paginator.page(page)
        except PageNotAnInteger:
            people = paginator.page(1)
        except EmptyPage:
            people = paginator.page(paginator.num_pages)

        if profiles.count() == 1 and not groups:
            return redirect("phonebook:profile_view", people[0].user.username)

        show_pagination = paginator.count > settings.ITEMS_PER_PAGE

    d = dict(
        people=people,
        search_form=form,
        limit=limit,
        show_pagination=show_pagination,
        groups=groups,
        curated_groups=curated_groups,
    )

    if request.is_ajax():
        return render(request, "search_ajax.html", d)

    return render(request, "phonebook/search.html", d)

 def test_get_functional_areas(self):
     GroupFactory.create()
     GroupFactory.create()
     UserFactory.create()
     UserFactory.create()
     cgroup_1 = GroupFactory.create(functional_area=True)
     GroupFactory.create(functional_area=False)
     eq_(set(Group.get_functional_areas()), set([cgroup_1]))

 def test_get_curated(self):
     GroupFactory.create()
     GroupFactory.create()
     user_1 = UserFactory.create()
     user_2 = UserFactory.create()
     cgroup_1 = GroupFactory.create(steward=user_1.userprofile)
     cgroup_2 = GroupFactory.create(steward=user_2.userprofile)
     eq_(set(Group.get_curated()), set([cgroup_1, cgroup_2]))

def index_groups(request):
    """Lists all public groups (in use) on Mozillians.

    Doesn't list functional areas, invisible groups, and groups with
    no vouched members
    """
    query = Group.get_non_functional_areas()
    template = 'groups/index_groups.html'
    return _list_groups(request, template, query)

def home(request):
    if request.user.is_authenticated():
        profile = request.user.get_profile()
        my_groups = profile.groups.exclude(steward=None).order_by("name")
        curated_groups = Group.get_curated()
        data = dict(groups=my_groups, curated_groups=curated_groups)
        return render(request, "phonebook/home.html", data)
    else:
        return render(request, "phonebook/home.html")

 def get_context_data(self, **kwargs):
     """Override method to pass more context data in the template."""
     context_data = super(PhonebookSearchView, self).get_context_data(**kwargs)
     context_data['functional_areas'] = Group.get_functional_areas()
     context_data['show_pagination'] = context_data['is_paginated']
     context_data['search_form'] = context_data['form']
     context_data['country'] = self.kwargs.get('country')
     context_data['region'] = self.kwargs.get('region')
     context_data['city'] = self.kwargs.get('city')
     return context_data

def index_groups(request):
    """Lists all public groups (in use) on Mozillians.

    Doesn't list functional areas, invisible groups, and groups with
    no vouched members
    """

    group_form = forms.CreateGroupForm(request.POST or None)
    if group_form.is_valid():
        group = group_form.save()
        group.curators.add(request.user.userprofile)
        return redirect(reverse('groups:group_edit', args=[group.url]))

    query = Group.get_non_functional_areas()
    template = 'groups/index_groups.html'
    context = {
        'group_form': group_form
    }
    return _list_groups(request, template, query, context)

    def test_search(self):
        group = GroupFactory.create(visible=True)
        GroupFactory.create(visible=False)

        eq_(set(Group.search(group.name)), set([group]))
        eq_(set(Group.search('roup'.format(group.name))), set([group]))

def index_functional_areas(request):
    """Lists all curated groups."""
    query = Group.get_curated()
    template = "groups/areas.html"
    return _list_groups(request, template, query)

 def test_search_matches_alias(self):
     group_1 = GroupFactory.create(name='lalo', visible=True)
     GroupAliasFactory.create(alias=group_1, name='foo')
     eq_(set(Group.search('foo')), set([group_1]))

 def test_search_no_query(self):
     eq_(len(Group.search('invalid')), 0)

 def test_search_case_insensitive(self):
     group = GroupFactory.create(visible=True)
     query = 'GROUP'
     eq_(set(Group.search(query)), set([group]))

def index_functional_areas(request):
    """Lists all functional areas."""
    query = Group.get_functional_areas()
    template = 'groups/index_areas.html'
    return _list_groups(request, template, query)

 def test_search_include_all(self):
     """Test Group searching not limited to auto_complete_only."""
     group_1 = GroupFactory.create(name='lola', auto_complete=True)
     group_2 = GroupFactory.create(name='lolo', auto_complete=False)
     eq_(set(Group.search('lo', auto_complete_only=False)),
         set([group_1, group_2]))