def ready(self):
# make Movie model searchable
movie = self.get_model("Movie")
watson.register(movie)
# make Collection model searchable
collection = self.get_model("Collection")
watson.register(collection)
def ready(self):
from watson import search as watson
Series = self.get_model('Series')
# Register the fields for the search
watson.register(Series,
fields=('name',),
store=('overview',))
def ready(self):
Area = self.get_model("Area")
watson.register(
Area.objects.public_base(),
fields=("title",),
store=("id",)
)
def setUp(self):
# If migrations are off, then this is needed to get the indices installed. It has to
# be called in the setUp() method, but multiple invocations should be safe.
call_command("installwatson", verbosity=0)
# Remove all the current registered models.
self.registered_models = watson.get_registered_models()
for model in self.registered_models:
watson.unregister(model)
# Register the test models.
watson.register(self.model1)
watson.register(self.model2, exclude=("id",))
complex_registration_search_engine.register(WatsonTestModel1, exclude=("content", "description",), store=("is_published",))
complex_registration_search_engine.register(WatsonTestModel2, fields=("title",))
# Create some test models.
self.test11 = WatsonTestModel1.objects.create(
title = "title model1 instance11",
content = "content model1 instance11",
description = "description model1 instance11",
)
self.test12 = WatsonTestModel1.objects.create(
title = "title model1 instance12",
content = "content model1 instance12",
description = "description model1 instance12",
)
self.test21 = WatsonTestModel2.objects.create(
title = "title model2 instance21",
content = "content model2 instance21",
description = "description model2 instance21",
)
self.test22 = WatsonTestModel2.objects.create(
title = "title model2 instance22",
content = "content model2 instance22",
description = "description model2 instance22",
)
def ready(self):
Business = self.get_model("Business")
Rating = self.get_model("Rating")
watson.register(Business)
watson.register(Rating,
fields=("id", "business__business_name", "user__email",
"user__paypal", "user__first_name",
"user__last_name"))
def ready(self):
super(EventsConfig, self).ready()
from watson import search as watson
from apps.events.models import Event
watson.register(Event)
def ready(self):
"""Registers articles with the activity streams plugin"""
# pylint: disable=invalid-name
from actstream import registry as action
from watson import search
Article = self.get_model('Article')
action.register(Article)
search.register(Article.objects.get_published())
def ready(self):
"""Registers the application with the activity streams plugin"""
# pylint: disable=invalid-name, import-outside-toplevel
from actstream import registry as action
from watson import search
Project = self.get_model("Project")
action.register(Project)
search.register(Project.objects.get_public())
def ready(self):
super().ready()
from watson import search as watson
import apps.mailinglists.signals # noqa: F401
from apps.mailinglists.models import MailEntity, MailGroup
watson.register(MailGroup)
watson.register(MailEntity)
def ready(self):
"""Registers the application with the activity streams plugin"""
from actstream import registry
from watson import search
Question = self.get_model('Question')
Answer = self.get_model('Answer')
registry.register(Question)
registry.register(Answer)
search.register(Question)
def ready(self):
"""Registers agencies with the activity streams plugin"""
# pylint: disable=invalid-name, import-outside-toplevel
from actstream import registry as action
from watson import search
Agency = self.get_model("Agency")
action.register(Agency)
search.register(Agency.objects.get_approved())
def ready(self):
User = self.get_model("CustomUser")
watson.register(User,
fields=("email", "paypal", "first_name", "last_name"))
WithdrawRequest = self.get_model("WithdrawRequest")
watson.register(WithdrawRequest,
fields=("id", "user__email", "user__paypal",
"user__first_name", "user__last_name",
"amount", "paid", "status"))
def ready(self):
User = django.contrib.auth.get_user_model()
if watson.is_registered(User):
watson.unregister(User)
watson.register(User,
UserSearchAdapter,
fields=('id', 'email', 'name', 'mdc', 'phone',
'group_str', 'owns', 'orgs'))
def ready(self):
import core.signals
Contact = self.get_model('Contact')
watson.register(Contact,
fields=(
"first_name",
"last_name",
"email",
"phone",
))
def ready(self):
super().ready()
from watson import search as watson
import apps.events.signals # noqa: F401
from apps.events.models import Event, Extras
watson.register(Event)
watson.register(Extras)
def ready(self):
"""Registers requests and communications with the activity streams plugin"""
from actstream import registry as action
from watson import search
FOIARequest = self.get_model('FOIARequest')
FOIACommunication = self.get_model('FOIACommunication')
FOIANote = self.get_model('FOIANote')
action.register(FOIARequest)
action.register(FOIACommunication)
action.register(FOIANote)
search.register(FOIARequest.objects.get_public())
def ready(self) -> None:
watson.register(
self.get_model("ArchivedSong"),
fields=("url", "artist", "title", "queries__query"),
store=("id", "title", "url", "artist", "counter"),
)
watson.register(
self.get_model("ArchivedPlaylist"),
fields=("title", "queries__query"),
store=("id", "title", "counter"),
)
def ready(self):
Article = self.get_model("Article")
News = self.get_model("News")
CategoryProduct = self.get_model("CategoryProduct")
Product = self.get_model("Product")
Gallery = self.get_model("Gallery")
watson.register(Article)
watson.register(News)
watson.register(CategoryProduct)
watson.register(Product)
watson.register(Gallery)
def ready(self):
"""Registers the application with the activity streams plugin"""
# pylint: disable=invalid-name, import-outside-toplevel
from actstream import registry
from watson import search
Question = self.get_model("Question")
Answer = self.get_model("Answer")
registry.register(Question)
registry.register(Answer)
search.register(Question)
def ready(self) -> None:
super().ready()
EmailTemplate = self.get_model('EmailTemplate')
watson.register(EmailTemplate, fields=(
'name',
'description',
'subject',
'content',
'html_content',
))
def ready(self):
StoryObject = self.get_model("StoryObject")
watson.register(StoryObject.objects.filter(published=True))
Story = self.get_model("Story")
watson.register(Story.objects.filter(published=True))
Chapter = self.get_model("Chapter")
watson.register(Chapter.objects.filter(published=True))
Scene = self.get_model("Scene")
watson.register(Scene.objects.filter(published=True))
Place = self.get_model("Place")
watson.register(Place.objects.all())
def ready(self):
StoryObject = self.get_model("StoryObject")
watson.register(StoryObject.objects.filter(published=True))
Story = self.get_model("Story")
watson.register(Story.objects.filter(published=True))
Chapter = self.get_model("Chapter")
watson.register(Chapter.objects.filter(published=True))
Scene = self.get_model("Scene")
watson.register(Scene.objects.filter(published=True))
Place = self.get_model("Place")
watson.register(Place.objects.all())
def ready(self):
Candidate = self.get_model("Candidate")
ElectedPosition = self.get_model("ElectedPosition")
Election = self.get_model("Election")
Party = self.get_model("Party")
Result = self.get_model("Result")
watson.register(Candidate)
watson.register(ElectedPosition)
watson.register(Election)
watson.register(Party)
watson.register(Result)
def ready(self) -> None:
# noinspection PyUnresolvedReferences
from .signals import handlers # noqa
from django_mailbox.models import Message
watson.register(Message, fields=(
'subject',
'from_header',
'to_header',
'html',
'text',
))
def ready(self):
super(AuthenticationConfig, self).ready()
from reversion import revisions as reversion
from watson import search as watson
import apps.authentication.signals # noqa: F401
from apps.authentication.models import OnlineUser, RegisterToken
reversion.register(RegisterToken)
watson.register(OnlineUser,
fields=("first_name", "last_name", "ntnu_username",
"nickname"))
def ready(self):
Post = self.get_model("Post")
Profile = self.get_model("Profile")
watson.register(Post, PostSearchAdapter, store=('url', ))
watson.register(Profile,
ProfileSearchAdapter,
fields=(
'user__username',
'full_name',
'bio',
),
store=('url', ))
def testRegistration(self):
# Register the model and test.
watson.register(WatsonTestModel1)
self.assertTrue(watson.is_registered(WatsonTestModel1))
self.assertRaises(watson.RegistrationError, lambda: watson.register(WatsonTestModel1))
self.assertTrue(WatsonTestModel1 in watson.get_registered_models())
self.assertTrue(isinstance(watson.get_adapter(WatsonTestModel1), watson.SearchAdapter))
# Unregister the model and text.
watson.unregister(WatsonTestModel1)
self.assertFalse(watson.is_registered(WatsonTestModel1))
self.assertRaises(watson.RegistrationError, lambda: watson.unregister(WatsonTestModel1))
self.assertTrue(WatsonTestModel1 not in watson.get_registered_models())
self.assertRaises(watson.RegistrationError, lambda: isinstance(watson.get_adapter(WatsonTestModel1)))
def testRegistration(self):
# Register the model and test.
watson.register(WatsonTestModel1)
self.assertTrue(watson.is_registered(WatsonTestModel1))
self.assertRaises(watson.RegistrationError, lambda: watson.register(WatsonTestModel1))
self.assertTrue(WatsonTestModel1 in watson.get_registered_models())
self.assertTrue(isinstance(watson.get_adapter(WatsonTestModel1), watson.SearchAdapter))
# Unregister the model and text.
watson.unregister(WatsonTestModel1)
self.assertFalse(watson.is_registered(WatsonTestModel1))
self.assertRaises(watson.RegistrationError, lambda: watson.unregister(WatsonTestModel1))
self.assertTrue(WatsonTestModel1 not in watson.get_registered_models())
self.assertRaises(watson.RegistrationError, lambda: isinstance(watson.get_adapter(WatsonTestModel1)))
def ready(self):
super(GalleryConfig, self).ready()
from watson import search as watson
import apps.gallery.signals # noqa: F401
from apps.gallery.models import ResponsiveImage
# Perform checks that necessary directories exist on the disk
from apps.gallery.util import verify_directory_structure
verify_directory_structure()
# Register the ResponsiveImage model for watson indexing
watson.register(ResponsiveImage)
def ready(self):
Enrollment = self.get_model("enrollment")
watson.register(Enrollment.public.all(),
StudentSearchAdapter,
fields=[
'student__username',
'student__bio',
'student__nickname',
'student__formal_name',
'student__pronoun',
'student__location',
'student__github_username',
'student__twitter_username',
],
store=['cohort_id', "search_type"])
def ready(self):
super(AuthenticationConfig, self).ready()
# The following stops pycharm from nagging about unused import statement
# noinspection PyUnresolvedReferences
import apps.authentication.signals # noqa: F401
from reversion import revisions as reversion
from watson import search as watson
from apps.authentication.models import OnlineUser, RegisterToken
reversion.register(RegisterToken)
watson.register(OnlineUser,
fields=('first_name', 'last_name', 'ntnu_username',
'nickname'))
def ready(self):
Staffing = self.get_model("staffing")
watson.register(Staffing.public.all(),
StaffSearchAdapter,
fields=[
'staffmember__username',
'staffmember__bio',
'staffmember__nickname',
'staffmember__formal_name',
'staffmember__pronoun',
'staffmember__location',
'staffmember__github_username',
'staffmember__twitter_username',
],
store=['cohort_id', "search_type"])
def ready(self):
super(GalleryConfig, self).ready()
from watson import search as watson
# The following stops pycharm from nagging about unused import statement
# noinspection PyUnresolvedReferences
import apps.gallery.signals # flake8: noqa
from apps.gallery.models import ResponsiveImage
# Perform checks that necessary directories exist on the disk
from apps.gallery.util import verify_directory_structure
verify_directory_structure()
# Register the ResponsiveImage model for watson indexing
watson.register(ResponsiveImage)
def ready(self):
YourModel = self.get_model("hobbytag")
watson.register(YourModel)
YourModel2 = self.get_model("features")
watson.register(YourModel2)
YourModel3 = self.get_model("extra_tag")
watson.register(YourModel3)
YourModel4 = self.get_model("states")
watson.register(YourModel4)
def ready(self):
HFI = self.get_model("HFI")
HFA = self.get_model("HFA")
HFC = self.get_model("HFC")
FNI = self.get_model("FNI")
watson.register(HFI)
watson.register(HFA)
watson.register(HFC)
watson.register(FNI)
def ready(self):
comida = self.get_model("Comida")
bebida = self.get_model("Bebida")
watson.register(
comida.objects.filter(disponibilidad=True),
fields=[
"nombre",
"categoria",
],
)
watson.register(
bebida.objects.filter(disponibilidad=True),
field=[
"nombre",
"categoria",
],
)
def tearDown(self):
# Re-register the old registered models.
for model in self.registered_models:
watson.register(model)
# Unregister the test models.
watson.unregister(self.model1)
watson.unregister(self.model2)
complex_registration_search_engine.unregister(WatsonTestModel1)
complex_registration_search_engine.unregister(WatsonTestModel2)
# Delete the test models.
WatsonTestModel1.objects.all().delete()
WatsonTestModel2.objects.all().delete()
del self.test11
del self.test12
del self.test21
del self.test22
# Delete the search index.
SearchEntry.objects.all().delete()
def ready(self):
# allow to use models in text search (django-watson)
Partner = self.get_model("Partner")
Product = self.get_model("Product")
Article = self.get_model("Article")
Category = self.get_model("Category")
TopCategory = self.get_model('TopCategory')
watson.register(Partner.objects.filter(is_hidden=False), fields=('title', 'desc',))
watson.register(Product.objects.filter(is_hidden=False),
fields=('title_ru', 'desc_short_ru', 'desc_full_ru', 'specifications_ru', 'options_ru',
'mentions_ru',)
)
watson.register(Article.objects.filter(is_hidden=False),
fields=('title_ru', 'text_ru', 'date', 'source_url', 'tags'),
store=('slug',)
)
watson.register(Category.objects.filter(is_hidden=False), fields=('title_ru', 'parent_category',))
watson.register(TopCategory.objects.filter(is_hidden=False), fields=('title_ru',))
def ready(self):
from django.contrib.auth.models import update_last_login
from django.contrib.auth.signals import user_logged_in, user_logged_out
from watson import search as watson_search
from inboxen import checks, search, signals
Inbox = self.get_model("Inbox")
Email = self.get_model("Email")
Request = self.get_model("Request")
# Unregister update_last_login handler
user_logged_in.disconnect(update_last_login)
# Search
watson_search.register(Email, search.EmailSearchAdapter)
watson_search.register(Inbox, search.InboxSearchAdapter)
pre_save.connect(signals.decided_checker, sender=Request, dispatch_uid="request_decided_checker")
user_logged_out.connect(signals.logout_message)
def ready(self):
from django.contrib.auth.models import update_last_login
from django.contrib.auth.signals import user_logged_in, user_logged_out
from watson import search as watson_search
from inboxen import checks # noqa
from inboxen import signals
from inboxen.search import watson as search
Inbox = self.get_model("Inbox")
Email = self.get_model("Email")
# Unregister update_last_login handler
user_logged_in.disconnect(update_last_login)
# Search
watson_search.register(Email, search.EmailSearchAdapter)
watson_search.register(Inbox, search.InboxSearchAdapter)
user_logged_out.connect(signals.logout_message)
def ready(self):
workspace = self.get_model('Workspace')
pe = self.get_model('PESig')
fun = self.get_model('FunctionSig')
watson.register(workspace)
watson.register(pe)
watson.register(fun)
def ready(self):
fundo = self.get_model("Fundo")
serie = self.get_model("Serie")
documento = self.get_model("Documento")
watson.register(fundo)
watson.register(serie)
watson.register(documento)
def ready(self):
Country = self.get_model("Country")
Player = self.get_model("Player")
Match = self.get_model("Match")
watson.register(Country,fields=("country_name","country_code","article", "continent"))
watson.register(Player,fields=("sur_name","full_name","clubname","position","biography"))
watson.register(Match,fields=("winner","score","location"))
def ready(self):
Event = self.get_model('Event')
CCReport = self.get_model('CCReport')
Fund = self.get_model('Fund')
Organization = self.get_model('Organization')
search.register(Event, store=('id',
'datetime_nice',
'description',
'location__name',
'org',
'status',
'short_services'))
search.register(Organization)
search.register(CCReport)
search.register(Fund)
from . import signals # NOQA
def ready(self):
watson.register(self.get_model('Article'))
def ready(self):
model = self.get_model("admission")
watson.register(model,fields=('title','tags','content'))
model2 = self.get_model("placement")
watson.register(model2,fields=('title','tags','content'))
model3 = self.get_model("hostel")
watson.register(model3,fields=('title','tags','content'))
model4 = self.get_model("acad")
watson.register(model4,fields=('title','tags','content'))
model5 = self.get_model("other")
watson.register(model5,fields=('title','tags','content'))
model6 = self.get_model("soc")
watson.register(model6,fields=('title','tags','content'))
def ready(self):
noticiasRomaModel = self.get_model("Entry")
watson.register(noticiasRomaModel)
def ready(self):
Article = self.get_model('Article')
watson.register(Article, adapter_cls=ArticleAdapter)
def ready(self):
post = self.get_model('Post')
watson.register(post)
def ready(self):
from cms.models import PageBaseSearchAdapter
Faq = self.get_model('Faq')
watson.register(Faq, adapter_cls=PageBaseSearchAdapter)
def ready(self):
# noinspection PyPep8Naming
Meeting = self.get_model('Meeting')
search.register(Meeting)
def ready(self):
from mcat import signals
product = self.get_model("Product")
watson.register(product)
def ready(self):
ContactPoint = self.get_model("ContactPoint")
from . import signal_handlers
watson.register(ContactPoint, ContactPointSearchAdapter)
def ready(self):
from watson import search as watson
Book = self.get_model('Book')
watson.register(Book)
def ready(self):
from makler.models import Makler
watson.register(Makler)
def ready(self):
Paper = self.get_model('Paper')
watson.register(Paper)
def ready(self):
from buyer.models import Buyer
watson.register(Buyer)
def ready(self):
search.register(self.get_model("User"), UserSearchAdapter, fields=('id', 'email', 'username', 'mdc', 'phone',
'first_name', 'last_name'))
def watson_register(model_name, adapter=SearchAdapter):
watson.register(self.get_model(model_name).published.all(),
adapter,
store=['get_model_name'])
