class DocumentIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
title = indexes.CharField(model_attr="title", boost=2)
# https://github.com/toastdriven/django-haystack/issues/569 - Necessary for sorting
title_sortable = indexes.CharField(indexed=False)
oid = indexes.IntegerField(model_attr='id')
type = indexes.CharField(faceted=True)
bbox_left = indexes.FloatField(model_attr="bbox_x0", null=True)
bbox_right = indexes.FloatField(model_attr="bbox_x1", null=True)
bbox_top = indexes.FloatField(model_attr="bbox_y0", null=True)
bbox_bottom = indexes.FloatField(model_attr="bbox_y1", null=True)
abstract = indexes.CharField(model_attr='abstract', boost=1.5)
owner = indexes.CharField(model_attr="owner", faceted=True, null=True)
modified = indexes.DateTimeField(model_attr="date")
detail_url = indexes.CharField(model_attr="get_absolute_url")
popular_count = indexes.IntegerField(model_attr="popular_count", default=0)
keywords = indexes.MultiValueField(model_attr="keyword_list", indexed=False, null=True, faceted=True)
thumbnail_url = indexes.CharField(model_attr="thumbnail_url", null=True)
def get_model(self):
return Project
def prepare_type(self, obj):
return "document"
def prepare_title_sortable(self, obj):
return obj.title.lower().lstrip()
class TagObjectIndex(indexes.SearchIndex):
mt_location = indexes.CharField(model_attr='media_tag__location', null=True)
mt_location_lat = indexes.FloatField(model_attr='media_tag__location_lat', null=True)
mt_location_lon = indexes.FloatField(model_attr='media_tag__location_lon', null=True)
#mt_approach = indexes.CharField(model_attr='media_tag__approach', null=True) # approach hidden for now
mt_topics = CommaSeperatedIntegerMultiValueField(model_attr='media_tag__topics', null=True)
mt_visibility = indexes.IntegerField(model_attr='media_tag__visibility', null=True)
class VerifiedUserAccountsIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True)
username = indexes.CharField()
email = indexes.CharField(model_attr='email')
network = indexes.CharField(model_attr='network')
account_id = indexes.IntegerField(model_attr='account_id')
price = indexes.DecimalField(model_attr='price')
cpm = indexes.FloatField(model_attr='cpm')
followers = indexes.IntegerField()
verified = indexes.IntegerField()
iid = indexes.IntegerField()
engagement = indexes.FloatField()
def get_model(self):
return VerifiedUserAccounts
def prepare_text(self, obj):
return [niche.niche for niche in obj.niches.all()]
def prepare_followers(self, obj):
try:
if obj.network == 'ig':
ig_user = IgUsers.objects.filter(id=obj.account_id)
if ig_user.exists():
return ig_user.first().followers
elif obj.network == 'tw':
tw_user = TwUsers.objects.filter(id=obj.account_id)
if tw_user.exists():
return tw_user.first().followers
except Exception as e:
return -1
def prepare_verified(self, obj):
return 1
def prepare_iid(self, obj):
return obj.account_id
def prepare_username(self, obj):
try:
if obj.network == 'ig':
ig_user = IgUsers.objects.filter(id=obj.account_id)
if ig_user.exists():
return ig_user.first().username
elif obj.network == 'tw':
tw_user = TwUsers.objects.filter(id=obj.account_id)
if tw_user.exists():
return tw_user.first().username
except Exception as e:
print e
return None
def prepare_engagement(self, obj):
return calculate_engagement_stats_for_verified_users(obj)
class ListingIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.EdgeNgramField(document=True, use_template=True)
title = indexes.CharField(model_attr='title', )
description = indexes.CharField(model_attr='description', )
slug = indexes.CharField(model_attr='slug')
price = indexes.FloatField(null=True, faceted=True)
currency = indexes.CharField(null=True, faceted=True)
type = indexes.CharField(model_attr='type', faceted=True)
offer = indexes.CharField(model_attr='offer', faceted=True)
baths = indexes.IntegerField(model_attr='baths', faceted=True)
beds = indexes.IntegerField(model_attr='beds', faceted=True)
location = indexes.CharField(model_attr='location', null=True, faceted=True)
featured = indexes.BooleanField(model_attr='featured', faceted=True)
coords = indexes.CharField(model_attr='coords')
size = indexes.FloatField(model_attr='size', faceted=True)
agent = indexes.CharField(model_attr='agent', faceted=True)
image = indexes.CharField(null=True)
absolute_url = indexes.CharField(null=True)
date_updated = indexes.DateTimeField(model_attr='last_modified')
def get_model(self):
return Listing
def index_queryset(self, using=None):
"""Used when the entire index for model is updated."""
return self.get_model().objects.filter(last_modified__lte=datetime.datetime.now())
def get_updated_field(self):
return 'last_modified'
def prepare_price(self, listing):
return listing.price.amount
def prepare_currency(self, listing):
return '%s' % listing.price.currency
def prepare_location(self, listing):
if listing.location is not None:
return '%s' % listing.location
return ""
def prepare_agent(self, listing):
if listing.agent is not None:
return '%s' % listing.agent
return ""
def prepare_image(self, listing):
try:
return get_thumbnail(listing.main_image.image, '640x480', crop='center', quality=99).url
except:
return ''
def prepare_absolute_url(self, listing):
return listing.absolute_url
class ExportAreaIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
name = indexes.CharField(model_attr="name")
order_num = indexes.IntegerField(model_attr="order_num")
latitude = indexes.FloatField(model_attr="latitude")
longitude = indexes.FloatField(model_attr="longitude")
show_at_zoom = indexes.IntegerField(model_attr="show_at_zoom")
show_on_map = indexes.BooleanField(model_attr="show_at_zoom")
def get_model(self):
return ExportArea
class CamIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.NgramField(document=True, use_template=True)
price = indexes.IntegerField(model_attr='price', faceted=True)
avgrating = indexes.FloatField(model_attr='avg_rating', faceted=True)
numrat = indexes.IntegerField(model_attr='number_of_ratings', faceted=True)
sentiscore = indexes.FloatField(model_attr='sentiment_score', faceted=True)
def get_model(self):
return Camera
def index_queryset(self):
return self.get_model().objects.all()
class LocalCouponIndex(CouponIndex):
coupon_ref_id = indexes.IntegerField(model_attr='ref_id', null=True)
embedly_title = indexes.CharField(model_attr='embedly_title', null=True)
embedly_description = indexes.CharField(model_attr='embedly_description',
null=True)
restrictions = indexes.CharField(model_attr='restrictions', null=True)
directlink = indexes.CharField(model_attr='directlink', null=True)
price = indexes.FloatField(model_attr='price', null=True)
listprice = indexes.FloatField(model_attr='listprice', null=True)
discount = indexes.FloatField(model_attr='discount', null=True)
percent = indexes.IntegerField(model_attr='percent', null=True)
merchant_location = indexes.LocationField(
model_attr='merchant_location__get_location', null=True)
online = indexes.BooleanField(model_attr='online', null=True)
lastupdated = indexes.DateTimeField(model_attr='lastupdated', null=True)
mobilequery = indexes.CharField(use_template=True, null=True)
provider_slug = indexes.CharField(model_attr='coupon_network__code',
null=True)
provider = indexes.CharField(model_attr='coupon_network__name', null=True)
category_slugs = indexes.MultiValueField(null=True)
categories = indexes.MultiValueField(null=True)
is_duplicate = indexes.BooleanField(model_attr='is_duplicate', null=True)
status = indexes.CharField(model_attr='status', null=True)
merchant_ref_id = indexes.IntegerField(model_attr='merchant__ref_id',
null=True)
merchant_name = indexes.CharField(model_attr='merchant__name', null=True)
merchant_link = indexes.CharField(model_attr='merchant__link', null=True)
merchant_address = indexes.CharField(
model_attr='merchant_location__address', null=True)
merchant_locality = indexes.CharField(
model_attr='merchant_location__locality', null=True)
merchant_region = indexes.CharField(model_attr='merchant_location__region',
null=True)
merchant_postal_code = indexes.CharField(
model_attr='merchant_location__postal_code', null=True)
related_deals_count = indexes.IntegerField(null=True)
def get_model(self):
return Coupon
def index_queryset(self, using=None):
return self.get_model().all_objects.filter(ref_id_source='sqoot')
def prepare_categories(self, obj):
return [c.name for c in obj.categories.all()]
def prepare_category_slugs(self, obj):
return [c.code for c in obj.categories.all()]
def prepare_related_deals_count(self, obj):
return Coupon.all_objects.filter(related_deal=obj).count()
class InvoiceIndex(CustomSearchIndex):
text = indexes.CharField(document=True, use_template=True)
object_type = indexes.CharField(model_attr='object_type', null=True)
object_id = indexes.IntegerField(model_attr='object_id', null=True)
bill_to = indexes.CharField(model_attr='bill_to')
bill_to_first_name = indexes.CharField(model_attr='bill_to_first_name',
default='')
bill_to_last_name = indexes.CharField(model_attr='bill_to_last_name',
default='')
bill_to_company = indexes.CharField(model_attr='bill_to_company',
default='')
bill_to_address = indexes.CharField(model_attr='bill_to_address',
default='')
bill_to_city = indexes.CharField(model_attr='bill_to_city', default='')
bill_to_state = indexes.CharField(model_attr='bill_to_state', default='')
bill_to_zip_code = indexes.CharField(model_attr='bill_to_zip_code',
default='')
bill_to_country = indexes.CharField(model_attr='bill_to_country',
default='')
bill_to_phone = indexes.CharField(model_attr='bill_to_phone', default='')
bill_to_email = indexes.CharField(model_attr='bill_to_email', default='')
total = indexes.FloatField(model_attr='total')
balance = indexes.FloatField(model_attr='balance')
create_dt = indexes.DateTimeField(model_attr='create_dt')
creator = indexes.CharField(model_attr='creator', null=True)
creator_username = indexes.CharField(model_attr='creator_username',
default='')
owner = indexes.CharField(model_attr='owner', null=True)
owner_username = indexes.CharField(model_attr='owner_username', default='')
status = indexes.BooleanField(model_attr='status')
status_detail = indexes.CharField(model_attr='status_detail')
# PK: needed for exclude list_tags
primary_key = indexes.CharField(model_attr='pk')
order = indexes.DateTimeField()
def get_updated_field(self):
return 'update_dt'
def prepare_object_type(self, obj):
myobj = obj.get_object()
if myobj:
return myobj._meta.verbose_name
return obj.object_type
def prepare_order(self, obj):
return obj.create_dt
class ItemIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
title = indexes.CharField(model_attr='title')
price = indexes.FloatField(model_attr='price')
discount_price = indexes.FloatField(model_attr='discount_price')
category = indexes.CharField(model_attr='category')
label = indexes.CharField(model_attr='label')
#image = indexes.ImageField(model_attr='image')
def get_model(self):
return Item
def index_queryset(self, using=None):
return self.get_model().objects.all()
class WhooshRoundTripSearchIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, default="")
name = indexes.CharField()
is_active = indexes.BooleanField()
post_count = indexes.IntegerField()
average_rating = indexes.FloatField()
price = indexes.DecimalField()
pub_date = indexes.DateField()
created = indexes.DateTimeField()
tags = indexes.MultiValueField()
sites = indexes.MultiValueField()
# For a regression involving lists with nothing in them.
empty_list = indexes.MultiValueField()
def get_model(self):
return MockModel
def prepare(self, obj):
prepped = super().prepare(obj)
prepped.update(
{
"text": "This is some example text.",
"name": "Mister Pants",
"is_active": True,
"post_count": 25,
"average_rating": 3.6,
"price": Decimal("24.99"),
"pub_date": date(2009, 11, 21),
"created": datetime(2009, 11, 21, 21, 31, 00),
"tags": ["staff", "outdoor", "activist", "scientist"],
"sites": [3, 5, 1],
"empty_list": [],
}
)
return prepped
class ProfileIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
username = indexes.CharField(model_attr='user__username')
name = indexes.CharField(model_attr='name')
job_title = indexes.CharField(model_attr='job_title')
location = indexes.CharField(model_attr='location__name')
location_slug = indexes.CharField(model_attr='location__slug')
rate = indexes.FloatField(model_attr='rate')
is_available = indexes.BooleanField(model_attr='is_available')
languages = indexes.MultiValueField()
technologies = indexes.MultiValueField()
url = indexes.CharField(model_attr='get_absolute_url')
avatar = indexes.CharField(model_attr='get_avatar_url')
created_at = indexes.DateTimeField(model_attr='created_at')
# for autocomplete
username_auto = indexes.EdgeNgramField(model_attr='build_search_autocomplete')
def get_model(self):
return models.Profile
def index_queryset(self, using=None):
return self.get_model().objects.filter(is_ready=True, banned=False)
def prepare_languages(self, obj):
return [l.slug for l in obj.languages.all()]
def prepare_technologies(self, obj):
return [t.technology.slug for t in obj.get_techs_list()]
class ListingIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=False)
listing_id = indexes.IntegerField(model_attr='id')
artist_id = indexes.IntegerField(model_attr='get_artist_id')
artist_avatar = indexes.CharField(model_attr='get_artist_avatar')
artist_name = indexes.CharField(model_attr='get_artist_name')
salon_id = indexes.IntegerField(model_attr='get_salon_id')
salon_name = indexes.CharField(model_attr='get_salon_name')
salon_avatar = indexes.CharField(model_attr='get_salon_avatar')
title = indexes.NgramField(model_attr='title')
location = indexes.LocationField(model_attr='get_location')
description = indexes.NgramField(model_attr='description')
get_picture = indexes.CharField(model_attr='get_picture')
metadata = indexes.CharField(model_attr='metadata')
currency = indexes.CharField(model_attr='currency')
price = indexes.FloatField(model_attr='price')
likes = indexes.IntegerField(model_attr='likes')
comments = indexes.IntegerField(model_attr='comments')
tags = indexes.NgramField(model_attr='get_tags')
status = indexes.IntegerField(model_attr='status')
gender = indexes.IntegerField(model_attr='gender')
rating = indexes.IntegerField(model_attr='get_rating')
style = indexes.NgramField(model_attr='get_style')
def get_model(self):
return Listing
def index_queryset(self, using=None):
return self.get_model().objects.all().select_related('artist')
class WhooshRoundTripSearchIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, default='')
name = indexes.CharField()
is_active = indexes.BooleanField()
post_count = indexes.IntegerField()
average_rating = indexes.FloatField()
pub_date = indexes.DateField()
created = indexes.DateTimeField()
tags = indexes.MultiValueField()
sites = indexes.MultiValueField()
# For a regression involving lists with nothing in them.
empty_list = indexes.MultiValueField()
def prepare(self, obj):
prepped = super(WhooshRoundTripSearchIndex, self).prepare(obj)
prepped.update({
'text': 'This is some example text.',
'name': 'Mister Pants',
'is_active': True,
'post_count': 25,
'average_rating': 3.6,
'pub_date': date(2009, 11, 21),
'created': datetime(2009, 11, 21, 21, 31, 00),
'tags': ['staff', 'outdoor', 'activist', 'scientist'],
'sites': [3, 5, 1],
'empty_list': [],
})
return prepped
class EntityIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
entity_id = indexes.IntegerField(model_attr='id')
entity_hash = indexes.CharField(model_attr='entity_hash')
title = indexes.CharField(model_attr='title', boost=1.25, faceted=True)
brand = indexes.CharField(model_attr='brand', boost=1.50, faceted=True)
user = indexes.CharField(model_attr='user')
created_time = indexes.DateTimeField(model_attr='created_time')
price = indexes.FloatField(model_attr='price')
like_count = indexes.IntegerField(model_attr='like_count')
# selection index
is_in_selection = indexes.BooleanField(model_attr='is_in_selection')
enter_selection_time = indexes.DateTimeField(model_attr='enter_selection_time')
# category_name = indexes.CharField(model_attr='category_name',boost=1.50, faceted=True)
title_auto = indexes.EdgeNgramField(model_attr='title')
def get_model(self):
return Entity
def prepare_brand(self, obj):
brand = u''
if 'brand' in self.prepared_data:
brand_list = self.prepared_data['brand'].split()
brand = ''.join(brand_list)
return brand
def index_queryset(self, using=None):
return self.get_model().objects.filter(status__gt=Entity.new).using('slave').\
filter(buy_links__status=2).distinct()
class RecurringPaymentIndex(CustomSearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
user = indexes.CharField(model_attr='user', faceted=True)
user_object = indexes.CharField(model_attr='user', faceted=True)
description = indexes.CharField(model_attr='description')
payment_amount = indexes.FloatField(model_attr='payment_amount')
order = indexes.DateTimeField()
def get_model(self):
return RecurringPayment
def get_updated_field(self):
return 'update_dt'
def prepare_user_object(self, obj):
return obj.user.username
def prepare_user(self, obj):
return "%s" % (
obj.user.get_full_name,
)
def prepare_order(self, obj):
return obj.create_dt
def index_queryset(self, using=None):
return self.get_model()._default_manager.all().order_by('user')
class BookIndex(indexes.SearchIndex, indexes.Indexable):
abstract = indexes.CharField(model_attr='abstract')
name = indexes.CharField(model_attr='name')
text = indexes.CharField(document=True)
pages = indexes.IntegerField(model_attr='pages', faceted=True)
price = indexes.DecimalField(model_attr='price', faceted=True)
rating = indexes.FloatField(model_attr='rating', faceted=True)
book_id = indexes.CharField(model_attr='id', faceted=False)
pubdate = indexes.DateField(model_attr='pubdate', faceted=True)
category = indexes.CharField(model_attr='category', faceted=True)
publisher = indexes.CharField(model_attr='publisher', faceted=True)
pub_year = indexes.CharField(faceted=True)
def get_model(self):
return Book
def index_queryset(self, using=None):
return self.get_model().objects.all()
def prepare_author_set(self, obj):
return [author.name for author in obj.authors.all().order_by('-name')]
def prepare_pub_year(self, obj):
return obj.pubdate.year
def prepare_text(self, obj):
return u'{} {}'.format(obj.name, obj.abstract)
class SolrRoundTripSearchIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, default='')
name = indexes.CharField()
is_active = indexes.BooleanField()
post_count = indexes.IntegerField()
average_rating = indexes.FloatField()
price = indexes.DecimalField()
pub_date = indexes.DateField()
created = indexes.DateTimeField()
tags = indexes.MultiValueField()
sites = indexes.MultiValueField()
def get_model(self):
return MockModel
def prepare(self, obj):
prepped = super(SolrRoundTripSearchIndex, self).prepare(obj)
prepped.update({
'text': 'This is some example text.',
'name': 'Mister Pants',
'is_active': True,
'post_count': 25,
'average_rating': 3.6,
'price': Decimal('24.99'),
'pub_date': datetime.date(2009, 11, 21),
'created': datetime.datetime(2009, 11, 21, 21, 31, 00),
'tags': ['staff', 'outdoor', 'activist', 'scientist'],
'sites': [3, 5, 1],
})
return prepped
class TourPointLocationIndex(indexes.SearchIndex, indexes.Indexable):
"""
Index the TourPoint objects, defines which attributes will be indexed,
so we can serach for them.
"""
text = indexes.CharField(document=True)
name = indexes.CharField(model_attr='name')
category = indexes.CharField(model_attr='category')
coordinates = indexes.LocationField(model_attr="coordinates")
private = indexes.BooleanField(model_attr='private')
longitude = indexes.FloatField(model_attr='longitude')
latitude = indexes.FloatField(model_attr='latitude')
owner = indexes.CharField(model_attr='owner')
def get_model(self):
return TourPoint
class ExternalBaseIndexMixin(indexes.SearchIndex):
source = indexes.CharField(stored=True, indexed=False, model_attr='source')
portal = indexes.IntegerField(default=EXTERNAL_CONTENT_PORTAL_ID)
location = indexes.LocationField(null=True)
""" from StoredDataIndexMixin """
title = indexes.CharField(stored=True, indexed=False, model_attr='title')
# slug for linking
slug = indexes.CharField(stored=True, indexed=True, model_attr='slug')
url = indexes.CharField(stored=True, indexed=False, model_attr='url')
description = indexes.CharField(stored=True, indexed=False, model_attr='description')
# the small icon image, should be a 144x144 image
icon_image_url = indexes.CharField(stored=True, indexed=False, model_attr='icon_image_url')
# the small background image or None, should be a 500x275 image
background_image_small_url = indexes.CharField(stored=True, indexed=False, model_attr='background_image_small_url', null=True)
# the large background image or None, should be a 1000x550 image
background_image_large_url = indexes.CharField(stored=True, indexed=False, model_attr='background_image_large_url', null=True)
# group slug for linking, subject to implementing indexed
group_slug = indexes.CharField(stored=True, indexed=True, model_attr='group_slug', null=True)
# group name for linking, subject to implementing indexed
group_name = indexes.CharField(stored=True, indexed=False, model_attr='group_name', null=True)
# attendees for events, projects for groups
participant_count = indexes.IntegerField(stored=True, indexed=False, model_attr='participant_count', null=True)
# member count for projects/groups, group-member count for events, memberships for users
member_count = indexes.IntegerField(stored=True, indexed=False, model_attr='member_count', null=True)
# groups/projects: number of upcoming events
content_count = indexes.IntegerField(stored=True, indexed=False, model_attr='content_count', null=True)
""" from DefaultTagObjectIndex """
mt_location = indexes.CharField(stored=True, indexed=False, null=True, model_attr='mt_location')
mt_location_lat = indexes.FloatField(null=True, model_attr='mt_location_lat')
mt_location_lon = indexes.FloatField(null=True, model_attr='mt_location_lon')
mt_topics = CommaSeperatedIntegerMultiValueField(null=True, model_attr='mt_topics')
mt_visibility = indexes.IntegerField(stored=True, indexed=False, default=2)
mt_public = indexes.BooleanField(default=True)
text = TemplateResolveNgramField(document=True, model_attr='title')
def prepare_location(self, obj):
if obj.mt_location_lat and obj.mt_location_lon:
# this expects (lat,lon)!
return "%s,%s" % (obj.mt_location_lat, obj.mt_location_lon)
return None
class ProvInfraProjectIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
name = indexes.CharField()
province = indexes.CharField(faceted=True)
department = indexes.CharField(faceted=True)
status = indexes.CharField(faceted=True)
status_order = indexes.IntegerField()
primary_funding_source = indexes.CharField(faceted=True)
estimated_completion_date = indexes.DateField()
total_project_cost = indexes.FloatField()
latitude = indexes.CharField()
longitude = indexes.CharField()
url_path = indexes.CharField()
def get_model(self):
return ProvInfraProject
def prepare_name(sef, object):
return object.project_snapshots.latest().name
def prepare_status(sef, object):
return object.project_snapshots.latest().status
def prepare_status_order(self, object):
return status_order.get(object.project_snapshots.latest().status, 100)
def prepare_province(sef, object):
return object.project_snapshots.latest().province
def prepare_department(sef, object):
return object.project_snapshots.latest().department
def prepare_primary_funding_source(sef, object):
return object.project_snapshots.latest().primary_funding_source
def prepare_total_project_cost(sef, object):
return object.project_snapshots.latest().total_project_cost
def prepare_estimated_completion_date(sef, object):
date = object.project_snapshots.latest().estimated_completion_date
if date:
return date.isoformat()
def prepare_latitude(sef, object):
return object.project_snapshots.latest().latitude
def prepare_longitude(sef, object):
return object.project_snapshots.latest().longitude
def prepare_url_path(sef, object):
return object.get_absolute_url()
def should_update(self, instance, **kwargs):
return instance.project_snapshots.count()
def index_queryset(self, using=None):
return ProvInfraProject.objects.annotate(
project_snapshots_count=Count("project_snapshots")).filter(
project_snapshots_count__gte=1)
class IgUsersIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True)
username = indexes.CharField(model_attr='username')
followers = indexes.IntegerField(model_attr='followers')
email = indexes.CharField(model_attr='email')
userid = indexes.CharField(model_attr='userid')
verified = indexes.IntegerField()
iid = indexes.IntegerField()
cpm = indexes.FloatField()
network = indexes.CharField()
engagement = indexes.FloatField()
def get_model(self):
return IgUsers
def prepare_text(self, obj):
return [niche.hashtag for niche in obj.igusertags_set.all()]
def prepare_verified(self, obj):
verified_acc = VerifiedUserAccounts.objects.filter(account_id=obj.id,
network='ig')
exists = verified_acc.exists()
if exists:
return 1
else:
return 0
def prepare_iid(self, obj):
return obj.pk
def prepare_cpm(self, obj):
verified_acc = VerifiedUserAccounts.objects.filter(account_id=obj.id,
network='ig')
exists = verified_acc.exists()
if exists:
return verified_acc.first().cpm
else:
return -1
def prepare_engagement(self, obj):
return calculate_engagement_stats_2(obj)
def prepare_network(self, obj):
return 'ig'
class ItemForSaleIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
title = indexes.CharField(model_attr='title', boost=1.5)
#IFS
price = indexes.FloatField(model_attr='price') #purposely not decimal field as its bugged
#POST
owner = indexes.CharField(model_attr='owner')
owner_facebook_id = indexes.CharField(model_attr='owner_facebook_id', null=True)
time_created = indexes.DateTimeField(model_attr='time_created')
pending_buyer = indexes.CharField(model_attr='pending_buyer', null=True)
pending_flag = indexes.BooleanField(model_attr='pending_flag')
sold = indexes.BooleanField(model_attr='sold')
deleted = indexes.BooleanField(model_attr='deleted')
category = indexes.MultiValueField()
circles = indexes.MultiValueField()
approved = indexes.BooleanField(model_attr='approved')
#is_facebook_post = indexes.BooleanField(model_attr='is_facebook_post')
expire_date = indexes.DateTimeField(model_attr='expire_date')
#It's also important to note that you CAN NOT filter using an actual boolean value...which is sort of dumb.
# You HAVE to use either 'true' or 'false'. e.g. sqs = sqs.filter(mybool='true').
# Using True or False will behave like 'true', and cause errors.
def prepare_approved(self, obj):
# if obj.approved==False:
# return ''
# return True
# Kept to record the previous fix to boolean filtering not working
return obj.approved
def prepare_pending_flag(self, obj):
return obj.pending_flag
def prepare_sold(self, obj):
return obj.sold
def prepare_deleted(self, obj):
return obj.deleted
"""def prepare_is_facebook_post(self, obj):
if obj.is_facebook_post==False:
return ''
return True"""
def prepare_category(self, obj):
return [obj.category.id]
def prepare_circles(self, obj):
return [circle.pk for circle in obj.circles.all()]
def get_model(self):
return ItemForSale
def index_queryset(self, using=None):
"""Used when the entire index for model is updated."""
return self.get_model().objects.filter(time_created__lte=datetime.datetime.now())
class ImportRegionIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
name = indexes.CharField(model_attr="name")
order_num = indexes.IntegerField(model_attr="order_num")
latitude = indexes.FloatField(model_attr="latitude")
longitude = indexes.FloatField(model_attr="longitude")
show_at_zoom = indexes.IntegerField(model_attr="show_at_zoom")
show_on_map = indexes.BooleanField(model_attr="show_at_zoom")
import_area = indexes.CharField()
def get_model(self):
return ImportRegion
def prepare_import_area(self, obj):
if obj.import_area:
return obj.import_area.name
else:
return None
class JobIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
job_name = indexes.CharField(model_attr='name')
job_type = indexes.CharField(model_attr='j_type')
min_salary = indexes.FloatField(model_attr='min_salary')
max_salary = indexes.FloatField(model_attr='max_salary')
job_summary = indexes.CharField(model_attr='summary')
job_city = indexes.IntegerField(model_attr='city')
team_id = indexes.CharField(model_attr='team__id')
team_logo_path = indexes.CharField(model_attr='team__logo_path')
team_name = indexes.CharField(model_attr='team__name')
team_type = indexes.IntegerField(model_attr='team__b_type')
team_about = indexes.CharField(model_attr='team__about')
def get_model(self):
return Job
class SolrComplexFacetsMockSearchIndex(indexes.SearchIndex):
text = indexes.CharField(document=True, default='')
name = indexes.CharField(faceted=True)
is_active = indexes.BooleanField(faceted=True)
post_count = indexes.IntegerField()
post_count_i = indexes.FacetIntegerField(facet_for='post_count')
average_rating = indexes.FloatField(faceted=True)
pub_date = indexes.DateField(faceted=True)
created = indexes.DateTimeField(faceted=True)
sites = indexes.MultiValueField(faceted=True)
class GoodsInfoIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
good_rate = indexes.FloatField(model_attr='good_rate')
computer_id = indexes.CharField(model_attr='computer_id')
price = indexes.CharField(model_attr='price')
img_url = indexes.CharField(model_attr='img_url')
title = indexes.CharField(model_attr='title')
def get_model(self):
return Computer
class DocumentsIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
hotel_name = indexes.CharField(model_attr='hotel__name')
hotel_star = indexes.FloatField(model_attr='hotel__star')
hotel_rating = indexes.FloatField(model_attr='hotel__rating')
review_title = indexes.CharField(model_attr='title')
review_content = indexes.CharField(model_attr='content')
review_rating = indexes.FloatField(model_attr='rating')
date = indexes.DateField(model_attr='date', indexed=False)
label = indexes.CharField(model_attr='label__label')
hotel_url = indexes.CharField(model_attr='hotel__url', indexed=False)
image_url = indexes.CharField(model_attr='hotel__image_url', indexed=False)
def get_model(self):
return Hotel_Review
def index_queryset(self, using=None):
"""Used when the entire index for model is updated."""
return self.get_model().objects.filter(
created_at__lte=datetime.datetime.now())
class ProgramIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, use_template=True)
#Added this line so that filtering by fees didn't always return empty set
fees = indexes.FloatField(model_attr='fees')
def get_model(self):
return Program
def index_queryset(self, using=None):
#"""Used when the entire index for model is updated."""
return self.get_model().objects.filter(isPending=False)
class BlogSearchIndex(indexes.SearchIndex):
text = indexes.CharField(
document=True,
use_template=True,
template_name="search/indexes/core/mockmodel_text.txt",
)
name = indexes.CharField(model_attr="author", faceted=True)
date = indexes.DateField(model_attr="date")
datetime = indexes.DateField(model_attr="datetime")
number = indexes.IntegerField(model_attr="number")
boolean = indexes.BooleanField(model_attr="boolean")
# slug = indexes.CharField(indexed=False, model_attr="slug")
float_number = indexes.FloatField(model_attr="float_number")
month = indexes.CharField(indexed=False)
url = indexes.CharField(model_attr="url")
empty = indexes.CharField()
# Various MultiValueFields
sites = indexes.MultiValueField()
tags = indexes.MultiValueField()
keys = indexes.MultiValueField()
titles = indexes.MultiValueField()
def get_model(self):
return models.BlogEntry
def prepare_sites(self, obj):
return ["%d" % (i * obj.id) for i in range(1, 4)]
def prepare_tags(self, obj):
if obj.id == 1:
return ["a", "b", "c"]
elif obj.id == 2:
return ["ab", "bc", "cd"]
else:
return ["an", "to", "or"]
def prepare_keys(self, obj):
return [i * obj.id for i in range(1, 4)]
def prepare_titles(self, obj):
if obj.id == 1:
return ["object one title one", "object one title two"]
elif obj.id == 2:
return ["object two title one", "object two title two"]
else:
return ["object three title one", "object three title two"]
def prepare_month(self, obj):
return "%02d" % obj.date.month
def prepare_empty(self, obj):
return ""
class BlogSearchIndex(indexes.SearchIndex):
text = indexes.CharField(
document=True, use_template=True,
template_name='search/indexes/core/mockmodel_text.txt'
)
name = indexes.CharField(model_attr='author', faceted=True)
date = indexes.DateField(model_attr='date')
datetime = indexes.DateField(model_attr='datetime')
number = indexes.IntegerField(model_attr='number')
boolean = indexes.BooleanField(model_attr='boolean')
#slug = indexes.CharField(indexed=False, model_attr='slug')
float_number = indexes.FloatField(model_attr='float_number')
month = indexes.CharField(indexed=False)
url = indexes.CharField(model_attr='url')
empty = indexes.CharField()
# Various MultiValueFields
sites = indexes.MultiValueField()
tags = indexes.MultiValueField()
keys = indexes.MultiValueField()
titles = indexes.MultiValueField()
def get_model(self):
return models.BlogEntry
def prepare_sites(self, obj):
return ['%d' % (i * obj.id) for i in range(1, 4)]
def prepare_tags(self, obj):
if obj.id == 1:
return ['a', 'b', 'c']
elif obj.id == 2:
return ['ab', 'bc', 'cd']
else:
return ['an', 'to', 'or']
def prepare_keys(self, obj):
return [i * obj.id for i in range(1, 4)]
def prepare_titles(self, obj):
if obj.id == 1:
return ['object one title one', 'object one title two']
elif obj.id == 2:
return ['object two title one', 'object two title two']
else:
return ['object three title one', 'object three title two']
def prepare_month(self, obj):
return '%02d' % obj.date.month
def prepare_empty(self, obj):
return ''
