class SearchIndex(AbstractSearchIndex):
objects = SearchIndexManager()
# metadata
created = models.DateTimeField(blank=True, null=True)
updated = models.DateTimeField(blank=True, null=True)
author = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.SET_NULL,
blank=True,
null=True)
authors_name = models.CharField(max_length=255)
# document
title = models.TextField()
document = models.TextField()
comments = models.TextField()
document_search_vector = SearchVectorField()
comments_search_vector = SearchVectorField()
combined_search_vector = SearchVectorField()
@staticmethod
def get_updated_field():
return 'updated'
class Meta:
indexes = [
GinIndex(fields=['document_search_vector']),
GinIndex(fields=['comments_search_vector']),
GinIndex(fields=['combined_search_vector']),
]
class Videos(models.Model):
video_id = models.CharField(null=False, blank=False, max_length=200)
title = models.CharField(null=True, blank=True, max_length=500)
description = models.CharField(null=True, blank=True, max_length=5000)
publishedDateTime = models.DateTimeField()
thumbnailsUrls = models.URLField()
channel_id = models.CharField(null=False, blank=False, max_length=500)
channel_title = models.CharField(null=True, blank=True, max_length=500)
created = models.DateTimeField(auto_now_add=True, null=True, blank=True)
title_vector = SearchVectorField(null=True)
description_vector = SearchVectorField(null=True)
#Added indexes to Postgres DB
# https://www.postgresql.org/docs/current/textsearch-indexes.html
# I have used GIN Indexes because they work etter than normal indexes in case of text search, i.e, search where composite
# values( title and description in our case). The fields chosen are search vector fields on which searching would be done.
class Meta:
indexes = [GinIndex(fields=[
'description_vector',
'title_vector',
])]
# class Keys(models.Model):
# key = models.CharField(null=True, blank=True, max_length=200)
# value = models.BooleanField(null=True, blank=True)
class IndexEntry(Model):
content_type = ForeignKey(ContentType, on_delete=CASCADE)
# We do not use an IntegerField since primary keys are not always integers.
object_id = TextField()
content_object = GenericForeignKey()
# TODO: Add per-object boosting.
autocomplete = SearchVectorField()
body = SearchVectorField()
class Meta:
unique_together = ('content_type', 'object_id')
verbose_name = _('index entry')
verbose_name_plural = _('index entries')
indexes = [
GinIndex(fields=['autocomplete']),
GinIndex(fields=['body'])
]
def __str__(self):
return '%s: %s' % (self.content_type.name, self.content_object)
@property
def model(self):
return self.content_type.model
@classmethod
def add_generic_relations(cls):
for model in apps.get_models():
if class_is_indexed(model):
TextIDGenericRelation(cls).contribute_to_class(
model, 'index_entries')
class Snippet(models.Model):
user = models.ForeignKey(settings.AUTH_USER_MODEL,
related_name='snippets_created',
on_delete=models.CASCADE)
title = models.CharField(max_length=200, verbose_name="")
body = RichTextField()
publish = models.DateTimeField(default=timezone.now)
created = models.DateTimeField(auto_now_add=True)
updated = models.DateTimeField(auto_now=True)
slug = models.SlugField(max_length=300, unique=True)
author = models.CharField(user, max_length=500)
publishedd = SnippetManager()
explanation = RichTextField()
user_like = models.ManyToManyField(settings.AUTH_USER_MODEL,
related_name='snippets_liked',
blank=True)
tags = TaggableManager()
title_vector = SearchVectorField(null=True)
explanation_vector = SearchVectorField(null=True)
# comments_vector = SearchVectorField(null=True)
# author_vector = SearchVectorField(null=True)
class Meta:
indexes = [GinIndex(fields=["title_vector", "explanation_vector"])]
ordering = ('-created', )
def get_absolute_url(self):
return reverse('csnip:snippet_detail', args=[self.created.year, \
self.created.month,\
self.created.day,self.slug])
def __str__(self):
return self.title
def annotate_search_vectors(qs):
if connection.vendor == 'postgresql': # pragma: no cover
from django.contrib.postgres.search import SearchVectorField
qs = qs.annotate(
title_search_vector=RawSQL('title_search_vector', [],
output_field=SearchVectorField()),
content_search_vector=RawSQL('content_search_vector', [],
output_field=SearchVectorField()))
return qs
class User(AbstractUser):
# User Roles (very basic for now)
LAWYER = "LAWYER"
LEGAL_ENG = 'LEGAL_ENG'
ADMIN = 'ADMIN'
VIEWONLY = 'VIEWONLY'
USER_ROLE = [
(VIEWONLY, _('View Only')),
(LAWYER, _('Lawyer')),
(LEGAL_ENG, _('Legal Engineer')),
(ADMIN, _('All Privileges (Dangerous!)')),
]
# First Name and Last Name do not cover name patterns
# around the globe.
name = CharField(_("Name of User"), blank=True, max_length=255)
# Override e-mail field so that it is required and unique
email = EmailField(_('email address'), blank=False, unique=True)
# User role
role = CharField(
max_length=24,
blank=False,
null=False,
choices=USER_ROLE,
default=LAWYER,
)
# Some tips on how to setup postgres indexing: http://rubyjacket.com/build/django-psql-fts.html
email_vector = SearchVectorField(null=True)
name_vector = SearchVectorField(null=True)
username_vector = SearchVectorField(null=True)
objects = GremlinUserManager()
def get_absolute_url(self):
return reverse("users:detail", kwargs={"username": self.username})
class Meta:
indexes = [
GinIndex(fields=[
'email_vector',
'name_vector',
'username_vector',
])
]
class UserProfile(AbstractBaseUser, PermissionsMixin):
"""Database Models In The System"""
gender = models.ForeignKey(Gender, on_delete=models.SET_NULL, null=True)
status = models.ForeignKey(UserStatus,
on_delete=models.SET_NULL,
null=True)
email = models.EmailField(max_length=255, unique=True)
first_name = models.CharField(max_length=255)
last_name = models.CharField(max_length=255)
full_name = SearchVectorField(null=True)
header = models.CharField(max_length=255, null=True)
about_me = models.CharField(max_length=255, null=True)
full_information = SearchVectorField(null=True)
date_of_birth = models.DateField(default=datetime.date.today)
phone = PhoneField(blank=True, help_text='Contact phone number')
is_active = models.BooleanField(default=True)
notification_newsletter = models.BooleanField(default=True)
notifictioon_post = models.BooleanField(default=True)
is_staff = models.BooleanField(default=False)
created_date = models.DateTimeField(default=timezone.now)
objects = MyUserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['first_name', "last_name"]
class Meta:
indexes = [
BrinIndex(fields=['created_date']),
GinIndex(fields=["full_name"]),
GinIndex(fields=["full_information"])
]
# def get_full_name(self):
# """Returns the first_name plus the last_name, with a space in between"""
# full_name = '%s %s' % (self.first_name, self.last_name)
# return full_name
# def get_short_name(self):
# """Returns the first name """
# return self.first_name
def __str__(self):
"""Return string representation of user"""
return self.email
class Meta:
indexes = [models.Index(fields=['id'])]
class Investigation(models.Model):
name = models.CharField(max_length=255, unique=True)
institution = models.CharField(max_length=255)
description = models.TextField()
values = models.ManyToManyField('Value',
related_name="investigations",
blank=True)
categories = models.ManyToManyField('Category',
related_name='investigations',
blank=True)
#Stuff for searching
search_vector = SearchVectorField(null=True)
class Meta:
indexes = [GinIndex(fields=['search_vector'])]
def __str__(self):
return self.name
#override save to update the search vector field
def save(self, *args, **kwargs):
super().save(*args, **kwargs)
@classmethod
def update_search_vector(self):
sv = (SearchVector('name', weight='A') +
SearchVector('description', weight='B') +
SearchVector('institution', weight='C'))
Investigation.objects.update(search_vector=sv)
class Dataset(models.Model):
created = models.DateTimeField(auto_now_add=True)
updated = models.DateTimeField(auto_now=True)
related_publications = models.ManyToManyField(Publication,
related_name='datasets')
keywords = models.ManyToManyField(Keyword, related_name='datasets')
# replace with a FileField
path = models.CharField(max_length=MAX_CHAR_LENGTH)
size = models.BigIntegerField()
genotype = models.CharField(max_length=MAX_CHAR_LENGTH, null=True)
subject_id = models.CharField(max_length=MAX_CHAR_LENGTH, null=True)
age = models.DurationField(null=True)
date_of_birth = models.DateTimeField(null=True)
number_of_electrodes = models.IntegerField(null=True)
lab = models.CharField(max_length=MAX_CHAR_LENGTH, null=True)
session_start_time = models.DateField(null=True)
experimenter = models.CharField(max_length=MAX_CHAR_LENGTH, null=True)
session_id = models.CharField(max_length=MAX_CHAR_LENGTH, null=True)
species = models.CharField(max_length=MAX_CHAR_LENGTH, null=True)
identifier = models.CharField(max_length=MAX_CHAR_LENGTH, null=True)
session_description = models.CharField(max_length=1023, null=True)
experiment_description = models.CharField(max_length=1023, null=True)
institution = models.CharField(max_length=MAX_CHAR_LENGTH, null=True)
number_of_units = models.IntegerField(null=True)
nwb_version = models.CharField(max_length=MAX_CHAR_LENGTH, null=True)
search_vector = SearchVectorField(null=True, editable=False)
class Meta:
indexes = [GinIndex(fields=['search_vector'])]
class Process(models.Model):
name = models.CharField(max_length=255, unique=True)
description = models.TextField(blank=True)
citation = models.TextField(blank=True)
upstream = models.ManyToManyField('self',
related_name="downstream",
blank=True)
parameters = models.ManyToManyField('Value',
related_name="processes",
blank=True)
categories = models.ManyToManyField('Category',
related_name="processes",
blank=True)
search_vector = SearchVectorField(null=True)
def __str__(self):
return "%s (%s)" % (self.name, self.citation)
class Meta:
indexes = [GinIndex(fields=['search_vector'])]
def save(self, *args, **kwargs):
super().save(*args, **kwargs)
@classmethod
def update_search_vector(self):
Process.objects.update(
search_vector=(SearchVector('name', weight='A') +
SearchVector('citation', weight='B') +
SearchVector('description', weight='C') +
SearchVector('category__name', weight='D')))
class Committee(BaseModel):
fec_id = models.CharField(max_length=10, primary_key=True)
committee_name = models.CharField(max_length=255, blank=True, null=True)
street_1 = models.CharField(max_length=255, blank=True, null=True)
street_2 = models.CharField(max_length=255, blank=True, null=True)
city = models.CharField(max_length=255, blank=True, null=True)
state = models.CharField(max_length=20, blank=True, null=True)
zipcode = models.CharField(max_length=10, blank=True, null=True)
treasurer_last_name = models.CharField(max_length=255, blank=True, null=True)
treasurer_first_name = models.CharField(max_length=255, blank=True, null=True)
treasurer_middle_name = models.CharField(max_length=255, blank=True, null=True)
treasurer_prefix = models.CharField(max_length=255, blank=True, null=True)
treasurer_suffix = models.CharField(max_length=255, blank=True, null=True)
committee_type = models.CharField(max_length=1, blank=True, null=True)
committee_designation = models.CharField(max_length=1, blank=True, null=True)
name_search = SearchVectorField(null=True)
def __str__(self):
return self.committee_name if self.committee_name else self.fec_id
class Meta:
indexes = [
models.Index(fields=['fec_id']),
models.Index(fields=['committee_name']),
GinIndex(fields=['name_search']),
]
def find_committee_by_name(search_term):
#does full text search on committee name and returns matching committees
query = SearchQuery(search_term)
return Committee.objects.filter(name_search=query)
class Post(models.Model):
"""Post to be used for a recipe"""
user = models.ForeignKey(
settings.AUTH_USER_MODEL,
on_delete=models.CASCADE
)
category = models.ForeignKey(
PostCategory, on_delete=models.CASCADE)
title = models.CharField(max_length=255)
content = models.CharField(max_length=255)
full_title_content = SearchVectorField(null=True)
bookmarks = models.IntegerField(default=0)
visible = models.BooleanField(default=False)
pending = models.BooleanField(default=False)
created_date = models.DateTimeField(
default=timezone.now)
tag = models.ManyToManyField(Tag, through='PostTag')
def __str__(self):
return self.title
class Meta:
indexes = [
BrinIndex(fields=['created_date']),
models.Index(fields=['id', 'category']),
GinIndex(fields=["full_title_content"])
]
class Car(models.Model):
name = models.CharField(max_length=255)
brand = models.CharField(max_length=255)
search = SearchVectorField(null=True)
def __str__(self):
return self.name
class File(models.Model):
created_at = models.DateTimeField("Criado em", auto_now_add=True)
updated_at = models.DateTimeField("Atualizado em", auto_now=True)
url = models.URLField("Arquivo", db_index=True)
content = models.TextField("Conteúdo", null=True, blank=True)
content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
object_id = models.PositiveIntegerField(db_index=True)
content_object = GenericForeignKey("content_type", "object_id")
checksum = models.CharField(max_length=128, null=True, blank=True)
s3_url = models.URLField("URL externa", null=True, blank=True)
s3_file_path = models.CharField(max_length=300, null=True, blank=True)
external_code = models.CharField("Código externo",
max_length=10,
null=True,
blank=True,
db_index=True)
search_vector = SearchVectorField(null=True, editable=False)
class Meta:
verbose_name = "Arquivo"
verbose_name_plural = "Arquivos"
indexes = [GinIndex(fields=["search_vector"])]
unique_together = ("url", "content_type", "object_id")
ordering = ["-created_at"]
def __repr__(self):
return f"[{self.content_type}] {self.url}"
def __str__(self):
return f"Arquivo ({self.pk}) de {self.content_type} ({self.object_id})"
class DocumentIndex(models.Model):
document = models.ForeignKey(Document, on_delete=models.CASCADE)
combined_text = models.TextField()
combined_titles = models.TextField()
root_title = models.TextField()
doc_root = models.SlugField(max_length=200) # denormalized
search_vector = SearchVectorField()
@classmethod
def from_document(cls, document):
doc_and_children = document.get_descendants(include_self=True)
return cls(
document=document,
combined_text='\n'.join(d.text for d in doc_and_children
if d.text),
combined_titles='\n'.join(d.title for d in doc_and_children
if d.title),
root_title=document.title or '',
doc_root=document.label_string.split('-')[0],
)
@classmethod
def rebuild_search_vectors(cls):
cls.objects.update(search_vector=(
# note that the root title gets double-counted, as it's also in
# combined_titles
SearchVector('root_title', weight='B') +
SearchVector('combined_titles', weight='A') +
SearchVector('combined_text', weight='B')))
class Sputnic(models.Model):
title = models.TextField(blank=True)
author = models.CharField(max_length=500, blank=True)
description = models.TextField(blank=True)
date = models.CharField(max_length=100, blank=True)
time = models.CharField(max_length=100, blank=True)
domain = models.CharField(max_length=200, blank=True)
url = models.CharField(max_length=500, blank=True)
route_api = models.CharField(max_length=500, blank=True)
heading = models.CharField(max_length=100, blank=True)
date_get = models.CharField(max_length=100, blank=True)
time_get = models.CharField(max_length=100, blank=True)
search_vector = SearchVectorField(null=True)
json_field = JSONField(null=True)
class Meta:
ordering = ['date_get']
indexes = [GinIndex(fields=['search_vector'])]
def get_absolute_url(self):
return reverse('sputnic:detail', args=(self.pk, ))
def save(self, *args, **kwargs):
super().save(*args, **kwargs)
if 'update_fields' not in kwargs or 'search_vector' not in kwargs[
'update_fields']:
vector = SearchVector('title', config='russian') + \
SearchVector('description', config='russian')
Sputnic.objects.filter(pk=self.pk).update(search_vector=vector)
class BaseModel(models.Model):
created = models.DateTimeField()
tags = models.ManyToManyField(Tag, blank=True)
slug = models.SlugField(max_length=64)
metadata = JSONField(blank=True, default={})
search_document = SearchVectorField(null=True)
def created_unixtimestamp(self):
return arrow.get(self.created).timestamp
def tag_summary(self):
return u' '.join(t.tag for t in self.tags.all())
def get_absolute_url(self):
return '/%d/%s/%d/%s/' % (
self.created.year, MONTHS_3[self.created.month].title(),
self.created.day, self.slug
)
def edit_url(self):
return "/admin/blog/%s/%d/" % (
self.__class__.__name__.lower(), self.id
)
class Meta:
abstract = True
ordering = ('-created',)
indexes = [
GinIndex(fields=['search_document'])
]
class Question(models.Model):
internal_id = models.CharField(max_length=256, blank=True, null=True)
sp_ref = models.CharField(max_length=128, blank=True, null=True)
sub_type = models.CharField(max_length=128, blank=True, null=True)
member = models.ForeignKey(Person, blank=True, null=True)
party = models.CharField(max_length=256, blank=True, null=True)
date = models.DateField(auto_now=False,
auto_now_add=False,
default=timezone.now)
answer_date = models.DateField(auto_now=False,
auto_now_add=False,
default=timezone.now,
blank=True,
null=True)
text = models.TextField(blank=True, null=True)
answer_text = models.TextField(blank=True, null=True)
answered_by = models.CharField(max_length=256, blank=True, null=True)
has_been_scraped = models.BooleanField(default=False)
search_vector = SearchVectorField(null=True)
class Meta(object):
indexes = [GinIndex(fields=['search_vector'])]
def __str__(self):
return (self.sp_ref)
class Post(models.Model):
text = models.CharField('Text', max_length=9000)
img = models.ImageField(storage=fs)
create_date = models.DateField('Date', auto_now_add=True)
title = models.CharField('Title', max_length=100)
author = models.ForeignKey(User, on_delete=models.CASCADE)
category = models.ForeignKey('Category',
on_delete=models.DO_NOTHING,
null=True,
blank=True)
tag = models.ManyToManyField('Tag')
disabled = models.BooleanField(default=False)
approved = models.BooleanField(default=False)
search_vector = SearchVectorField(null=True, editable=False)
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse('blog:post', kwargs={'pk': self.pk})
def delta_time(self):
pass
class Meta:
ordering = ['-create_date']
class Incident(models.Model):
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
rg_id = models.CharField(max_length=255, unique=True)
url = models.CharField(max_length=255)
title = models.CharField(max_length=1000,
blank=True,
default="",
null=True)
description = models.TextField()
date = models.DateField()
orig_city = models.CharField(max_length=255, null=True)
orig_county = models.CharField(max_length=255, null=True)
orig_address = models.CharField(max_length=255, null=True)
location = models.ForeignKey("Location",
on_delete=models.SET_NULL,
null=True)
chronicle = models.ForeignKey("Chronicle",
on_delete=models.SET_NULL,
null=True)
search_vector = SearchVectorField(null=True)
phrases = models.ManyToManyField("Phrase")
contexts = models.TextField(null=True, blank=True)
factums = models.TextField(null=True, blank=True)
motives = models.TextField(null=True, blank=True)
tags = models.TextField(null=True, blank=True)
objects = IncidentSearchQuerySet.as_manager()
class Meta(object):
indexes = [GinIndex(fields=["search_vector"])]
class Location(models.Model):
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
house_number = models.CharField(max_length=255, null=True)
street = models.CharField(max_length=255, null=True)
postal_code = models.CharField(max_length=255, null=True)
district = models.CharField(max_length=255, null=True)
city = models.CharField(max_length=255, null=True)
county = models.CharField(max_length=255, null=True)
state = models.CharField(max_length=255, null=True)
country = models.CharField(max_length=255, null=True)
geolocation = models.PointField(geography=True, default=Point(0.0, 0.0))
# this is not geographical but speeds up computation for e.g. bounding box check
geolocation_geometry = models.PointField(default=Point(0.0, 0.0))
search_vector = SearchVectorField(null=True)
# not actually used, only hotfix for importing data :/
latitude = models.FloatField(null=True)
longitude = models.FloatField(null=True)
objects = LocationSearchQuerySet.as_manager()
class Meta(object):
indexes = [GinIndex(fields=["search_vector"])]
class Analysis(models.Model):
# This is an instantiation/run of a Process and its Steps
name = models.CharField(max_length=255)
date = models.DateTimeField(blank=True)
location = models.CharField(max_length=255, blank=True)
process = models.ForeignKey('Process', on_delete=models.CASCADE)
# Just in case this analysis had any extra steps, they can be defined and tagged here
# outside of a Process
extra_steps = models.ManyToManyField('Step')
# Run-specific parameters can go in here, but I guess Measures can too
values = models.ManyToManyField('Value', related_name='analyses')
categories = models.ManyToManyField('Category',
related_name='analyses',
blank=True)
search_vector = SearchVectorField(null=True)
class Meta:
indexes = [GinIndex(fields=['search_vector'])]
def save(self, *args, **kwargs):
super().save(*args, **kwargs)
@classmethod
def update_search_vector(self):
Analysis.objects.update(
search_vector=(SearchVector('name', weight='A') +
SearchVector('date', weight='B') +
SearchVector('location', weight='C')))
class PharmaCompany(models.Model):
name = models.CharField(max_length=255)
slug = models.SlugField(max_length=255)
sub_names = models.TextField(blank=True)
web = models.CharField(max_length=1024, blank=True)
payments_url = models.CharField(max_length=1024, blank=True)
country = models.CharField(max_length=2, default='DE')
search_vector = SearchVectorField(default='')
objects = PharmaCompanyManager()
class Meta:
verbose_name = _('Pharma Company')
verbose_name_plural = _('Pharma Companies')
ordering = ('name',)
def __str__(self):
return self.name
def natural_key(self):
return (self.slug,)
@models.permalink
def get_absolute_url(self):
return ('eurosfueraerzte:eurosfueraerzte-companydetail', (), {
'slug': self.slug
})
def get_sub_names(self):
return [x for x in self.sub_names.splitlines() if x]
class BaseDocumentIndex(models.Model):
content_type = models.CharField(max_length=255, db_index=True)
object_id = models.CharField(max_length=255)
body = SearchVectorField()
output_data = JSONField(null=True, blank=True)
search_data = JSONField(null=True, blank=True)
metadata = JSONField(null=True, blank=True)
geom_point = models.MultiPointField(null=True, blank=True)
geom_linestring = models.MultiLineStringField(null=True, blank=True)
geom_polygon = models.MultiPolygonField(null=True, blank=True)
indexing = models.BooleanField(default=False, db_index=True)
objects = DocumentIndexBaseManager()
objects_default = models.Manager()
def get_geom(self, srid):
value = self.geom_point or self.geom_linestring or self.geom_polygon
if value:
value.transform(srid)
return json.loads(value.json)
class Meta:
abstract = True
unique_together = ('content_type', 'object_id')
index_together = [['content_type', 'indexing']]
indexes = [GinIndex(fields=['body'])]
def __str__(self):
return '%s: %s' % (self.content_type, self.object_id)
class SearchableBill(models.Model):
"""
This model associates a single version's text with a given bill.
This is done for a few reasons:
* bills with multiple versions aren't weighted more heavily than others
* this makes querying quite a bit more efficient (no need to deduplicate results)
We'll also store error results, assuming that they're somewhat persistent.
"""
bill = models.OneToOneField(Bill,
related_name="searchable",
null=True,
on_delete=models.CASCADE)
version_link = models.OneToOneField(BillVersionLink,
related_name="searchable",
null=True,
on_delete=models.CASCADE)
search_vector = SearchVectorField(default=None)
all_titles = models.TextField(default="")
raw_text = models.TextField(default="")
is_error = models.BooleanField(default=False)
created_at = models.DateTimeField(auto_now_add=True)
class Meta:
db_table = "opencivicdata_searchablebill"
indexes = [GinIndex(name="search_index", fields=["search_vector"])]
class Project(models.Model):
geography = models.ForeignKey(Geography,
on_delete=models.CASCADE,
null=False,
related_name="geographies")
function = models.CharField(max_length=255, blank=True)
project_description = models.CharField(max_length=255, blank=True)
project_number = models.CharField(max_length=30, blank=True)
project_type = models.CharField(max_length=20, blank=True)
mtsf_service_outcome = models.CharField(max_length=100, blank=True)
iudf = models.CharField(max_length=255, blank=True)
own_strategic_objectives = models.CharField(max_length=255, blank=True)
asset_class = models.CharField(max_length=255, blank=True)
asset_subclass = models.CharField(max_length=255, blank=True)
ward_location = models.CharField(max_length=255, blank=True)
longitude = models.FloatField(null=True)
latitude = models.FloatField(null=True)
content_search = SearchVectorField(null=True)
objects = ProjectManager()
class Meta:
indexes = [GinIndex(fields=["content_search"])]
def __str__(self):
return "%s - %s" % (self.geography, self.project_description)
class Article(models.Model):
headline = models.TextField()
content = models.TextField()
search_vector = SearchVectorField(null=True)
class Meta(object):
indexes = [GinIndex(fields=['search_vector'])]
class Contract(BaseModel):
entity = models.ForeignKey("Entity", null=True, on_delete=models.SET_NULL)
source_id = models.PositiveIntegerField(unique=True)
number = models.CharField(max_length=255)
amendment = models.CharField(max_length=255, blank=True, null=True)
slug = AutoSlugField(populate_from=["number", "amendment", "source_id"])
date_of_grant = models.DateTimeField()
effective_date_from = models.DateTimeField(db_index=True)
effective_date_to = models.DateTimeField(db_index=True)
service = models.ForeignKey("Service",
null=True,
on_delete=models.SET_NULL)
cancellation_date = models.DateTimeField(blank=True, null=True)
amount_to_pay = models.DecimalField(max_digits=20, decimal_places=2)
has_amendments = models.BooleanField()
document = models.ForeignKey("Document",
null=True,
on_delete=models.SET_NULL)
exempt_id = models.CharField(max_length=255)
contractors = models.ManyToManyField("Contractor")
parent = models.ForeignKey("self",
null=True,
on_delete=models.CASCADE,
related_name="amendments")
search_vector = SearchVectorField(null=True)
class Meta:
indexes = [GinIndex(fields=["search_vector"])]
def __str__(self):
if self.amendment:
return f"{self.number} - {self.amendment}"
return f"{self.number}"
class Report(models.Model):
location = models.CharField(max_length=250, blank=True)
shape = models.CharField(max_length=50, blank=True)
duration = models.CharField(max_length=50, blank=True)
description = models.TextField(blank=True)
latitude = models.DecimalField(
null=True,
blank=True,
decimal_places=2,
max_digits=10,
)
longitude = models.DecimalField(
null=True,
blank=True,
decimal_places=2,
max_digits=10,
)
reported_at = models.DateField(null=True, blank=True)
occurred_at = models.DateField(null=True, blank=True)
search_vector = SearchVectorField(null=True, blank=True)
objects = ReportQuerySet.as_manager()
def __str__(self):
return self.location
class BaseModel(models.Model):
created = models.DateTimeField(default=timezone.now)
tags = models.ManyToManyField(Tag, blank=True)
slug = models.SlugField(max_length=64)
latitude = models.FloatField(blank=True, null=True)
longitude = models.FloatField(blank=True, null=True)
metadata = JSONField(blank=True, default=dict)
search_document = SearchVectorField(null=True)
import_ref = models.TextField(max_length=64, null=True, unique=True)
@property
def type(self):
return self._meta.model_name
def created_unixtimestamp(self):
return arrow.get(self.created).timestamp
def tag_summary(self):
return " ".join(t.tag for t in self.tags.all())
def get_absolute_url(self):
d = timezone.localdate(self.created)
return reverse("blog_archive_item",
args=[d.year, d.month, d.day, self.slug])
def edit_url(self):
return "/admin/blog/%s/%d/" % (self.__class__.__name__.lower(),
self.id)
class Meta:
abstract = True
ordering = ("-created", )
indexes = [GinIndex(fields=["search_document"])]
config = getattr(self.lhs, 'config', None)
self.rhs = SearchQuery(self.rhs, config=config)
rhs, rhs_params = super(SearchVectorExact, self).process_rhs(qn, connection)
rhs = '(to_tsquery(%s::regconfig, %s))'
parts = (s.replace("'", '') for s in rhs_params[1].split())
rhs_params[1] = ' & '.join("'%s':*" % s for s in parts if s)
return rhs, rhs_params
def as_sql(self, qn, connection):
lhs, lhs_params = self.process_lhs(qn, connection)
rhs, rhs_params = self.process_rhs(qn, connection)
params = lhs_params + rhs_params
return '%s @@ %s' % (lhs, rhs), params
SearchVectorField.register_lookup(SearchVectorStartsWith)
def perc(val, total):
if total == 0.0:
return 0.0
return val / total * 100
class PharmaCompanyManager(models.Manager):
def get_by_natural_key(self, slug):
return self.get(slug=slug)
def _get_type_aggregation(self, obj, df, kind, max_amount):
type_df = df.query('recipient_kind == @kind')