def testSearchEmailParts(self):
     with watson.update_index():
         self.test11.content = "[email protected]"
         self.test11.save()
     self.assertEqual(watson.search("fooo").count(), 1)
     self.assertEqual(watson.search("baar.com").count(), 1)
     self.assertEqual(watson.search("[email protected]").count(), 1)

def search(request):
    if request.GET['q']:
        name="All Sections"
        section="all"
        query=request.GET['q']
        if 'section' in request.GET:
            section=request.GET['section']
            if section=="all":
                results=watson.search(query)
            else:
                sec=[]
                model=get_model(section)
                name=get_name(section)
                sec.append(model)
                results=watson.search(query,models=tuple(sec))
        else:
            results=watson.search(query)
    else:
        return HttpResponseRedirect(reverse('home'))
    length=len(results)
    paginator = Paginator(results,10)
    page = request.GET.get('page')
    try:
        obj=paginator.page(page)
    except:
        obj=paginator.page(1)
    context = {'name':name,'obj':obj,'section':section,'length':length,'range':range(1,obj.paginator.num_pages+1),'query':query}
    return render(request,'search.html',context)

def search_idb(request):

	query = request.GET.get('q', '') #returns string of args from search
	q_list = []

	search_results = watson.search(query) #AND search
	q_list.append(search_results)

	arg_list = query.split() #split on whitespace to get search terms

	
	if len(arg_list) > 1: #OR search for each individual term
		for search_term in arg_list:
			more_results = (watson.search(search_term))
			q_list.append(more_results)
	

	list_of_models = []
	for item in q_list:
		for result in item:
			if result not in list_of_models:
				list_of_models.append(result)

	count = len(list_of_models)
	context = RequestContext(request, {'query': query, 'count': count,'results': search_results, 'list': list_of_models})

	t = loader.get_template('watson/search.html')
	return HttpResponse(t.render(context))

def search(request):
    if request.GET['q']:
        name="All Sections"
        section="all"
        query=request.GET['q']
        if 'section' in request.GET:
            section=request.GET['section']
            if section=="all":
                results=watson.search(query)
            elif section=="tl":
                name="Teach and Learn"
                results=watson.search(query,models=tuple([Tutorial,EducationalResource,Wiki,Snippet]))
            elif section=="forum":
                name="Forum"
                results=watson.search(query,models=tuple([Announcement,Event,Blog,News]))
            else:
                sec=[]
                model=get_model(section)
                name=get_name(section)
                sec.append(model)
                results=watson.search(query,models=tuple(sec))
        else:
            results=watson.search(query)
    else:
        return HttpResponseRedirect(reverse('home'))
    length=len(results)
    paginator = Paginator(results,15)
    page = request.GET.get('page')
    try:
        obj=paginator.page(page)
    except:
        obj=paginator.page(1)
    context = {'name':name,'obj':obj,'section':section,'length':length,'range':range(1,obj.paginator.num_pages+1),'query':query}
    return render(request,'search.html',context)

def get_search_results(query, slug):
    if slug not in SEARCH_PARAMS:
        raise Http404('Invalid search slug.')
    models = SEARCH_PARAMS[slug]
    object_list = list(watson.search(query, models=models))
    # Perform the search with the rest of the models:
    if models:
        object_list += list(watson.search(query, exclude=models))
    return object_list

 def testBuildWatsonCommand(self):
     # Hack a change into the model using a bulk update, which doesn't send signals.
     WatsonTestModel1.objects.filter(id=self.test11.id).update(title="fooo")
     # Test that no update has happened.
     self.assertEqual(watson.search("fooo").count(), 0)
     # Run the rebuild command.
     call_command("buildwatson", verbosity=0)
     # Test that the update is now applies.
     self.assertEqual(watson.search("fooo").count(), 1)

def search(request):
    context = RequestContext(request)

    query = ""
    query_words = []

    if ('q' in request.GET) and request.GET['q'].strip():
        query = request.GET['q']

    query_items = query.split()

    and_search = watson.search(query, ranking=True)

    for a in and_search:
        print(a.url)
        print(a)

    results = list(and_search)

    for item in query_items:
        or_search = list(watson.search(item, ranking=True))
        for o in or_search:
            if not o in results:
                results.append(o)


    snippets = []

    for i in range(0, len(results)):
        final_sentence = ""
        sentences = splitParagraph(results[i].content)

        for s in list(sentences):
            if(s.lower().find(query.lower()) != -1):
                sentences.remove(s)
                s = s.lower().replace(query.lower(), "<B class='search_term'>"+query.lower()+"</B>")
                final_sentence += " " + s
                break

        for q_item in query_items:
            for s in list(sentences):
                if(s.lower().find(query.lower()) != -1):
                    sentences.remove(s)
                    s = s.lower().replace(query.lower(), "<B class='search_term'>"+query.lower()+"</B>")
                    final_sentence += " " + s
                    break

        final_sentence += " "
        snippets.append(final_sentence)

    zipped = None
    if len(results) > 0:
        zipped = zip(results, snippets)
    length_results = len(results)

    return render_to_response('search.html', {"query": query, "length_results": length_results, "results": zipped}, context)

 def testBuildWatsonCommand(self):
     # This update won't take affect, because no search context is active.
     self.test11.title = "fooo"
     self.test11.save()
     # Test that no update has happened.
     self.assertEqual(watson.search("fooo").count(), 0)
     # Run the rebuild command.
     call_command("buildwatson", verbosity=0)
     # Test that the update is now applies.
     self.assertEqual(watson.search("fooo").count(), 1)

 def testNestedUpdateInSkipContext(self):
     with watson.skip_index_update():
         self.test21.title = "baar"
         self.test21.save()
         with watson.update_index():
             self.test11.title = "fooo"
             self.test11.save()
     # We should get "fooo", but not "baar"
     self.assertEqual(watson.search("fooo").count(), 1)
     self.assertEqual(watson.search("baar").count(), 0)

 def testUnpublishedModelsNotFound(self):
     # Make sure that there are four to find!
     self.assertEqual(watson.search("tItle Content Description").count(), 4)
     # Unpublish two objects.
     self.test11.is_published = False
     self.test11.save()
     self.test21.is_published = False
     self.test21.save()
     # This should return 4, but two of them are unpublished.
     self.assertEqual(watson.search("tItle Content Description").count(), 2)

 def testUpdateSearchIndex(self):
     # Update a model and make sure that the search results match.
     self.test11.title = "fooo"
     self.test11.save()
     # Test a search that should get one model.
     exact_search = watson.search("fooo")
     self.assertEqual(len(exact_search), 1)
     self.assertEqual(exact_search[0].title, "fooo")
     # Delete a model and make sure that the search results match.
     self.test11.delete()
     self.assertEqual(watson.search("fooo").count(), 0)

def search(request):
    context = RequestContext(request)
    query = ""
    query_words = []
    if ('q' in request.GET) and request.GET['q'].strip():
        query = request.GET['q']
    
    query_words = query.split()
    
    and_results = watson.search(query, ranking=True)
    results = list(and_results)

    for wd in query_words:
        or_results = list(watson.search(wd, ranking=True))
        for r in or_results:
            if not r in results:
                results.append(r)
    
    snippets = []
    
    
    for i in range(0, len(results)):
        final_sentence = ""

        sentences = splitParagraph(results[i].content)

        #First highlight terms in sentences matching the phrase
        for s in list(sentences):
            if(s.lower().find(query.lower()) != -1):
                sentences.remove(s)
                s = s.lower().replace(query.lower(), "<B class='search_term'>"+query.lower()+"</B>")
                final_sentence += "..." + s
                break

        #Then highlight the separate words of a query separately
        for q_wd in query_words:
            for s in list(sentences):
                if (s.lower().find(q_wd.lower()) != -1):
                    sentences.remove(s)
                    s = s.lower().replace(q_wd.lower(), "<B class='search_term'>"+q_wd.lower()+"</B>")
                    final_sentence += "..." + s
                    break

        final_sentence += "..."
        snippets.append(final_sentence)

    zipped = None
    if len(results) > 0:
        zipped = zip(results, snippets)
    length_results = len(results)

    return render_to_response('mythos/search.html', {"query": query, "length_results": length_results, "results": zipped}, context)

def tag_search(request, klass, template):
    """Search subset of models with the given tag.

    Usess ``watson`` for the full-text search.
    """
    # Generate a queryset from a model, manager or queryset:
    form = SearchForm(request.GET)
    page_no = pagination.get_page_no(request.GET)
    if form.is_valid():
        queryset = get_queryset(klass)
        object_list = watson.search(
            form.cleaned_data['q'], models=(queryset, ))
        pagination_qs = '&%s' % urlencode({'q': form.cleaned_data['q']})
    else:
        object_list = []
        pagination_qs = ''
    page = pagination.get_page(object_list, page_no)
    page.object_list_top = [o.object for o in page.object_list_top]
    page.object_list_bottom = [o.object for o in page.object_list_bottom]
    context = {
        'page': page,
        'form': form,
        'pagination_qs': pagination_qs,
    }
    return TemplateResponse(request, template, context)

 def testSearchWithAccent(self):
     WatsonTestModel1.objects.create(
         title = "title model1 instance12",
         content = "content model1 instance13 café",
         description = "description model1 instance13",
     )
     self.assertEqual(watson.search("café").count(), 1)

 def testSearchWithApostrophe(self):
     WatsonTestModel1.objects.create(
         title = "title model1 instance12",
         content = "content model1 instance13 d'Argent",
         description = "description model1 instance13",
     )
     self.assertEqual(watson.search("d'Argent").count(), 1)

 def place_recommendations(self):
     import watson
     out = []
     for i in xrange(len(self.data_objects)):
         out.append(
             watson.search(self.data_objects[i])[0].object)
     return out

 def testSearchWithLeadingApostrophe(self):
     WatsonTestModel1.objects.create(
         title = "title model1 instance12",
         content = "'content model1 instance13",
         description = "description model1 instance13",
     )
     self.assertTrue(watson.search("'content").exists())  # Some database engines ignore leading apostrophes, some count them.

 def testCanOverridePublication(self):
     # Unpublish two objects.
     with watson.update_index():
         self.test11.is_published = False
         self.test11.save()
     # This should still return 4, since we're overriding the publication.
     self.assertEqual(watson.search("tItle Content Description", models=(WatsonTestModel2, WatsonTestModel1._base_manager.all(),)).count(), 4)

 def get_context_data(self, **kwargs):
     context = super(SearchView, self).get_context_data(**kwargs)
     kwargs = self.request.GET
     query = kwargs.get("q", "")
     pacotes = watson.search(query)
     context["object_list"] = [i.object for i in pacotes]
     context["query"] = query
     return context

 def testExcludedModelQuerySet(self):
     # Test a search that should get all models.
     self.assertEqual(watson.search("TITLE", exclude=(WatsonTestModel1.objects.filter(title__icontains="FOOO"), WatsonTestModel2.objects.filter(title__icontains="FOOO"),)).count(), 4)
     # Test a search that should get two models.
     self.assertEqual(watson.search("MODEL1", exclude=(WatsonTestModel1.objects.filter(
         title__icontains = "INSTANCE21",
         description__icontains = "INSTANCE22",
     ),)).count(), 2)
     self.assertEqual(watson.search("MODEL2", exclude=(WatsonTestModel2.objects.filter(
         title__icontains = "INSTANCE11",
         description__icontains = "INSTANCE12",
     ),)).count(), 2)
     # Test a search that should get one model.
     self.assertEqual(watson.search("INSTANCE11", exclude=(WatsonTestModel1.objects.filter(
         title__icontains = "MODEL2",
     ),)).count(), 1)
     self.assertEqual(watson.search("INSTANCE21", exclude=(WatsonTestModel2.objects.filter(
         title__icontains = "MODEL1",
     ),)).count(), 1)
     # Test a search that should get no models.
     self.assertEqual(watson.search("INSTANCE11", exclude=(WatsonTestModel1.objects.filter(
         title__icontains = "MODEL1",
     ),)).count(), 0)
     self.assertEqual(watson.search("INSTANCE21", exclude=(WatsonTestModel2.objects.filter(
         title__icontains = "MODEL2",
     ),)).count(), 0)