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 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):
Entry = self.get_model("Entry")
watson.register(Entry, fields=("title", "description"))
Comment = self.get_model("Comment")
watson.register(Comment, fields=(
"title",
"description",
))
def ready(self):
# Tells what watson what model to search within
Article = self.get_model("Article")
# Configures Watson to only search pub=True entries and add front, back and description to meta
watson.register(
Article.objects.filter(published_status=True),
store=("game_name", "game_review_cover", "game_review_back_cover", "game_review_description"),
)
def ready(self):
User = django.contrib.auth.get_user_model()
watson.register(User,
UserSearchAdapter,
fields=('id', 'email', 'profile__fullname',
'profile__mdc', 'profile__phone',
'profile__group_str', 'profile__owns',
'profile__orgs'))
def ready(self):
# imports here to circumvent RemovedInDjango19Warning: Model doesn't declare an explicit app_label
import watson
from app_book.models import Book, Offer
from app_user.models import User
disabledShowcases = User.objects.filter(showcaseDisabled=True).values_list('user_ptr')
bookIds = Offer.objects.exclude(seller_user_id__in=disabledShowcases).exclude(active = False).values_list('book', flat=True)
watson.register(Book.objects.filter(id__in=bookIds))
watson.register(User.objects.all())
def ready(self):
User = django.contrib.auth.get_user_model()
watson.register(User, UserSearchAdapter, fields=('id', 'email',
'profile__fullname',
'profile__mdc',
'profile__phone',
'profile__group_str',
'profile__owns',
'profile__orgs'))
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 testRegistration(self):
# Register the model and test.
watson.register(WatsonTestModel1)
self.assertTrue(watson.is_registered(WatsonTestModel1))
self.assertRaises(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(RegistrationError, lambda: watson.unregister(WatsonTestModel1))
self.assertTrue(WatsonTestModel1 not in watson.get_registered_models())
self.assertRaises(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(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(RegistrationError, lambda: watson.unregister(WatsonTestModel1))
self.assertTrue(WatsonTestModel1 not in watson.get_registered_models())
self.assertRaises(RegistrationError, lambda: isinstance(watson.get_adapter(WatsonTestModel1)))
def tearDownClass(cls):
#Unregister test models.
watson.unregister(Feed)
watson.unregister(Post)
watson.unregister(Topic)
# Re-register the old registered models.
for model in cls.registered_models:
watson.register(model)
# Unregister the test models.
cls.user.delete()
cls.f1_m.delete()
cls.f2_m.delete()
cls.f3_m.delete()
cls.f4_m.delete()
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 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):
Event = self.get_model('Event')
CCReport = self.get_model('CCReport')
Fund = self.get_model('Fund')
Organization = self.get_model('Organization')
watson.register(Event,
store=('id', 'datetime_nice', 'description',
'location__name', 'org', 'status',
'short_services'))
watson.register(Organization)
watson.register(CCReport)
watson.register(Fund)
def ready(self):
post_model = self.get_model('Post')
image_model = self.get_model('Image')
credit_model = self.get_model('Credit')
watson.register(post_model.objects.filter(published=True), fields=('heading', 'subheading', 'articletext', 'tags'))
watson.register(image_model.objects.filter(post__published=True))
watson.register(credit_model.objects.filter(post__published=True))
def ready(self):
post_model = self.get_model('Post')
image_model = self.get_model('Image')
credit_model = self.get_model('Credit')
watson.register(post_model.objects.filter(published=True),
fields=('heading', 'subheading', 'articletext',
'tags'))
watson.register(image_model.objects.filter(post__published=True))
watson.register(credit_model.objects.filter(post__published=True))
def setUpClass(cls):
call_command("installwatson", verbosity=0)
cls.registered_models = watson.get_registered_models()
# Remove all the current registered models.
for model in cls.registered_models:
watson.unregister(model)
# Register the test models.
watson.register(Feed)
watson.register(Post)
watson.register(Topic)
# init user
cls.user = User.objects.create_user(username="******",
email="*****@*****.**",
password="******")
cls.user.save()
#init videogame Feeds
Feed.createByURL("http://penny-arcade.com/feed").save()
Feed.createByURL("http://thepunchlineismachismo.com/feed").save()
Feed.createByURL(
"http://rss.escapistmagazine.com/articles/comicsandcosplay/comics/critical-miss.xml"
).save()
Feed.createByURL("http://xkcd.com/rss.xml").save()
Feed.createByURL(
"http://rss.nytimes.com/services/xml/rss/nyt/Golf.xml").save()
cls.f1_m = Feed.objects.get(URL="http://penny-arcade.com/feed")
cls.f1 = FeedSerializer(cls.f1_m).data
cls.f2_m = Feed.objects.get(
URL="http://thepunchlineismachismo.com/feed")
cls.f2 = FeedSerializer(cls.f2_m).data
cls.f3_m = Feed.objects.get(
URL=
"http://rss.escapistmagazine.com/articles/comicsandcosplay/comics/critical-miss.xml"
)
cls.f3 = FeedSerializer(cls.f3_m).data
cls.f4_m = Feed.objects.get(URL="http://xkcd.com/rss.xml")
cls.f4 = FeedSerializer(cls.f4_m).data
cls.f5_m = Feed.objects.get(
URL="http://rss.nytimes.com/services/xml/rss/nyt/Golf.xml")
cls.f5 = FeedSerializer(cls.f5_m).data
def ready(self):
BiblioUser = self.get_model("BiblioUser")
BiblioUser._meta.get_field_by_name('email')[0]._unique=True
watson.register(
BiblioUser.objects.filter(is_active=True),
store=("slug", "avatar_50x50_url","profil_url","username","class_name"),
fields=("slug","username"),
),
Livre = self.get_model("Livre")
watson.register(
Livre.objects.filter(phase__in=['GETMONEY','SUCCES','ECHEC','FEEDBACK'],is_active=True),
store=("titre", "image_50x50_url","url","class_name"),
fields=("titre", "tags__text",'resume','pourquoi_ce_livre','phrase_cle','annonces','biographie'),
)
UrlIndex = self.get_model("UrlIndex")
watson.register(
UrlIndex.objects.all(),
store=("url", "texte",'titre','image_url',"class_name"),
)
class Header(models.Model):
"""Header model
ordinal preserves the order of headers as in the original message
Object manager has a create() method that accepts name and data, it deals
with duplicated header names/data behind the scenes
"""
name = models.ForeignKey(HeaderName, on_delete=models.PROTECT)
data = models.ForeignKey(HeaderData, on_delete=models.PROTECT)
part = models.ForeignKey(PartList)
ordinal = models.IntegerField()
objects = PassThroughManager.for_queryset_class(HeaderQuerySet)()
def __unicode__(self):
return u"{0}".format(self.name.name)
# Unregister update_last_login handler
# See https://github.com/Inboxen/website/issues/156
from django.contrib.auth.signals import user_logged_in
from django.contrib.auth.models import update_last_login
user_logged_in.disconnect(update_last_login)
# Search
watson.register(Email, search.EmailSearchAdapter)
watson.register(Inbox, search.InboxSearchAdapter)
def ready(self):
Meeting = self.get_model('Meeting')
watson.register(Meeting)
('exportacion', 'Exportación'),
('domestica', 'Doméstica'),
)
tipo = StatusField('Tipo', choices_name='TIPO_CHOICES')
origen = models.CharField('Origen', max_length=15)
destino = models.CharField('Destino', max_length=15)
def __unicode__(self):
return u'{}-{}/{}'.format(self.tipo.capitalize(), self.origen,
self.destino)
if not watson.default_search_engine.is_registered(Empresa):
watson.register(Empresa, fields=(
'rut',
'nombre',
'contactos__email',
))
@receiver(post_save, sender=Ruta)
def update_empresa_index_on_ruta_save(sender, instance, **kwargs):
for i in instance.empresa_set.all():
i.save()
@receiver(post_save, sender=Contacto)
def update_empresa_index_on_contacto_save(sender, instance, **kwargs):
instance.empresa.save()
def ready(self):
Lecture = self.get_model('Lecture')
watson.register(Lecture)
)
order = models.PositiveIntegerField(
default=0
)
def __unicode__(self):
return self.question
class Meta:
verbose_name = "faq"
verbose_name_plural = "faqs"
ordering = ['order', 'id', 'question']
def get_absolute_url(self):
""" Gets the url of a Faq
Returns:
url of Person
"""
return "{}{}/".format(
self.page.page.get_absolute_url(),
self.url_title
)
watson.register(Faq)
class Meta:
db_table = 'user_profile'
def __unicode__(self):
return 'UserProfile: %s' % self.user.email
class WallItem(BaseModel):
"""
- Post to your own Wall
- Post to another profile's wall
"""
uuid = UUIDField(auto=True, db_index=True, primary_key=True)
receiver = models.ForeignKey('auth.User', related_name='wall_receiver')
author = models.ForeignKey('auth.User', related_name='wall_author')
content = models.TextField()
class Meta:
db_table = 'wall_posts'
def __unicode__(self):
return 'Wall: %s-%s' % (self.receiver.email, self.author.email)
watson.register(User)
watson.register(UserProfile)
slug = models.SlugField(max_length=255, blank=True)
url = models.URLField(blank=True)
attachment = models.FileField(upload_to='posts', blank=True)
mime_type = models.CharField(max_length=255, blank=True)
description = models.TextField(blank=True)
caption = models.TextField(blank=True)
def __unicode__(self):
return self.title
class BlogLink(models.Model):
"""Sidebar links."""
name = models.CharField(max_length=255)
url = models.URLField(max_length=500)
created = CreationDateTimeField()
order = models.IntegerField(default=0)
class Meta:
ordering = ('order',)
def __unicode__(self):
return self.name
# Search:
watson.register(
Post.published.all(),
search.PostSearchAdapter
)
ratings = Rating.objects.filter(work=self)
l = len(ratings)
self.mark = float(sum([r.mark for r in ratings]))/ l
self.mark_st = float(sum([r.mark_st for r in ratings]))/ l
self.mark_sz = float(sum([r.mark_sz for r in ratings]))/ l
self.mark_pr = float(sum([r.mark_pr for r in ratings]))/ l
self.save()
def add_collaborator(self, user):
self.collaborators.add(user)
self.save()
def get_collaborator(self):
try:
return self.collaborators.get().get_profile().nick
except:
return ''
def is_collaborator(self, user):
try:
return self.collaborators.get() == user
except:
return False
@staticmethod
def get_by_collaborator(user):
return user.collaborator.all()
watson.register(Work, fields=('description',))
class ApiKey(models.Model):
public_key = models.CharField(db_index=True, max_length=255)
private_key = models.CharField(db_index=True, max_length=255)
name = models.CharField(max_length=255)
has_been_seen = models.BooleanField(default=False)
def save(self):
if not self.id:
self.public_key = GenerateAPIKey()
self.private_key = ''.join(
random.choice(string.ascii_lowercase + string.digits)
for x in range(64))
super(ApiKey, self).save()
def __unicode__(self):
return self.name
class Meta:
ordering = ['name']
unique_together = ("public_key", "private_key")
watson.register(Machine, exclude=(
"report",
"errors",
"warnings",
))
watson.register(Fact)
watson.register(Condition)
page = models.ForeignKey(Faqs)
question = models.CharField(max_length=256)
answer = HtmlField()
url_title = models.CharField(max_length=256, unique=True)
order = models.PositiveIntegerField(default=0)
def __unicode__(self):
return self.question
class Meta:
verbose_name = "faq"
verbose_name_plural = "faqs"
ordering = ['order', 'id', 'question']
def get_absolute_url(self):
""" Gets the url of a Faq
Returns:
url of Person
"""
return "{}{}/".format(self.page.page.get_absolute_url(),
self.url_title)
watson.register(Faq)
ptsLayer = models.ForeignKey(PointLayer, null=True, blank=True)
attribution = models.CharField(max_length=250, null=True, blank=True)
isTimeSupported = models.BooleanField(default=False)
timeSeriesInfo = JSONField(null=True)
#this is {label:attribute name}
def save(self, *args, **kwargs):
self.description_search = re.sub("<.*?>", " ", self.description)
super(Layer, self).save(*args, **kwargs)
def __unicode__(self):
return u'%s' % (self.subject)
#maybe include connections future to aggregate to layers
watson.register(Layer)
class Points(models.Model):
Header = models.CharField(max_length=200, null=True, blank=True)
#Topic = models.ForeignKey(Layer, null=True, blank=True)
Map = models.CharField(max_length=200, null=True, blank=True)
Country = models.CharField(max_length=200, null=True, blank=True)
Title = models.CharField(max_length=200, db_index=True)
Story = tinymce_models.HTMLField()
pointlayer = models.ForeignKey(PointLayer)
#[125.6, 10.1] for geometry format --- potential for geoJSON object as well
geometry = LocationField(blank=True)
def __unicode__(self):
return u'%s' % (self.Title)
class Revision (models.Model):
# Docuemnto
documento = models.ForeignKey(Documento)
# Revisión y actualizacion
revision = models.IntegerField ()
f_actualizacion = models.DateField ()
# Archivos de la revisión
archivo = models.FileField(upload_to=subir_documento, blank = True, null = True)
# Identificación de cambios
cambios = models.TextField ()
# Trazabilidad
autor = models.ForeignKey(User, editable=False)
creacion = models.DateTimeField(auto_now_add=True)
actualiza = models.DateTimeField (auto_now = True)
def __unicode__ (self):
return u"%s rev %02d (%s)" % (self.documento, self.revision, self.f_actualizacion)
class Meta:
unique_together = (("documento", "revision"),)
verbose_name = "Revisión"
verbose_name_plural = "Control Revisiones"
# from watson import search as watson
import watson
watson.register(Documento, field=('texto_ayuda', 'nombre', 'slug'))
location_text = models.CharField(_("location"), max_length=255)
category = models.ForeignKey(Category, verbose_name=_("category"))
subject = models.CharField(_("subject"), max_length=255)
description = models.TextField(_("description"), blank=True, null=True)
media = models.ManyToManyField('base.Media', blank=True, null=True, related_name='appreciations_media+')
# comments = models.ManyToManyField(Comment, blank=True, null=True)
created_by = models.ForeignKey(settings.AUTH_USER_MODEL, related_name='appreciation_created_by_user', verbose_name=_("created by"))
created_at = models.DateTimeField(_("created at"), auto_now_add=True)
updated_at = models.DateTimeField(_("updated at"), auto_now=True)
def get_absolute_url(self):
return reverse('appreciations:view', kwargs={'pk': self.id})
def __unicode__(self):
return '%s - %s %s' % (self.pk, self.datetime, self.location_text)
def serialize(self):
data = model_to_dict(self)
data['created_by'] = self.created_by
data['created_at'] = self.created_at
data['updated_at'] = self.updated_at
data['category'] = self.category
data['media'] = self.media.all()
# data['comments'] = self.comments.all()
return data
import watson
watson.register(Report)
def ready(self):
Service = self.get_model("Service")
watson.register(Service, ServiceSearchAdapter)
Work=self.get_model("Work")
watson.register(Work, WorkSearchAdapter)
Secret=self.get_model("Secret")
watson.register(Secret, SecretSearchAdapter)
Promo=self.get_model("Promo")
watson.register(Promo, PromoSearchAdapter)
About=self.get_model("About")
watson.register(About, AboutSearchAdapter)
Staff=self.get_model("Staff")
watson.register(Staff, StaffSearchAdapter)
Index=self.get_model("Index")
watson.register(Index, IndexSearchAdapter)
def __unicode__(self):
return self.name
class Meta:
ordering = ['name']
class SalSetting(models.Model):
name = models.CharField(max_length=255, unique=True)
value = models.TextField()
def __unicode__(self):
return self.name
class ApiKey(models.Model):
public_key = models.CharField(db_index=True, max_length=255)
private_key = models.CharField(db_index=True, max_length=255)
name = models.CharField(max_length=255)
has_been_seen = models.BooleanField(default=False)
def save(self):
if not self.id:
self.public_key = GenerateAPIKey()
self.private_key = ''.join(random.choice(string.ascii_lowercase + string.digits) for x in range(64))
super(ApiKey, self).save()
def __unicode__(self):
return self.name
class Meta:
ordering = ['name']
unique_together = ("public_key", "private_key")
watson.register(Machine, exclude=("report", "errors", "warnings",))
watson.register(Fact)
watson.register(Condition)
return u'%s' % Est.objects.get(id = self.cid).genesymbol
class Bill(models.Model):
cartlists = models.ManyToManyField(Cartlist, related_name='b+', blank=True)
user = models.ForeignKey(User)
price = models.FloatField(default=0)
status = models.IntegerField(default=0)
# 0:submited 1:shipped 2:expired 3:canceled
name = models.CharField(max_length=30, default='')
contact = models.CharField(max_length=30, default='')
address = models.CharField(max_length=30, default='')
zipcode = models.CharField(max_length=30, blank=True)
express = models.CharField(max_length=30, default='EMS')
note = models.TextField(blank=True, default='')
insert = models.DateTimeField(auto_now_add=True)
update = models.DateTimeField(auto_now=True)
class Meta:
get_latest_by = "id"
def settle(self):
price = 0
lists = self.cartlists.all()
for list in lists:
price = price + list.price
return price
watson.register(Zfish, exclude=("abbreviation", "source", "note"))
watson.register(Est)
The Player model contains the player name, country they played for, their position,
their dob, the number of goals they made, and their original club.
A foreign key named country is maintained for the relation of Player to Country.
The __str__ method is used to return the name of the player.
"""
player = models.CharField(max_length=40, default="", primary_key=True)
team = models.ForeignKey('Country',
related_name='team',
to_field='country',
default='none')
position = models.CharField(max_length=2, default="")
dob = models.CharField(max_length=40, default="")
goals = models.CharField(max_length=2, default="")
club = models.CharField(max_length=40, default="")
def get_absolute_url(self):
return "/player/%s" % self.player
def __str__(self):
return self.player
import watson
watson.register(Match,
fields=("match", "scores", "penalties", "match_date",
"match_location", "man_of_the_match", "country_one",
"country_two"))
watson.register(Country, fields=("country", "coach", "top_scorer", "captain"))
watson.register(Player, fields=("player", "position", "dob", "club", "team"))
@type language: models.CharField(200)
@cvar language: Most common language spoken in this culture
@type related_figures: models.ManyToManyField('Figure')
@cvar related_figures: Many to many assocation associating Figures related to this Culture
@type related_cultures: models.ManyToManyField('self')
@cvar related_cultures: Many to many assocation associating Cultures similar to this Culture
@type related_stories: models.ManyToManyField('Story')
@cvar related_stories: Many to many assocation associating notable mythological stories belonging within this Culture
'''
name = models.CharField(max_length=200)
region = models.CharField(max_length=200)
history = models.CharField(max_length=10000)
language = models.CharField(max_length=200)
related_cultures = models.ManyToManyField('self')
def get_absolute_url(self):
return "/cultures/%i/" % self.id
def __unicode__(self):
return self.name
# -----
# Watson
# -----
import watson
watson.register(Figure)
watson.register(Culture)
watson.register(Story)
from django.db import models
from server.models import *
import watson
# Create your models here.
class Inventory(models.Model):
machine = models.ForeignKey(Machine)
datestamp = models.DateTimeField(auto_now=True)
sha256hash = models.CharField(max_length=64)
class Meta:
ordering = ['datestamp']
class InventoryItem(models.Model):
machine = models.ForeignKey(Machine)
name = models.CharField(db_index=True, max_length=255)
version = models.CharField(db_index=True, max_length=32)
bundleid = models.CharField(db_index=True, max_length=255)
bundlename = models.CharField(db_index=True, max_length=255)
path = models.TextField()
class Meta:
ordering = ['name', '-version']
watson.register(InventoryItem)
my guess is that I did actually know this, like at one point,
based on how it appears that I was gearing up to do stuff with
this class. That was a while ago, though, erm. """
z_ent = models.IntegerField(
db_column=u'Z_ENT',
primary_key=True)
z_name = models.TextField(
db_column=u'Z_NAME',
blank=True)
z_super = models.IntegerField(
null=True,
db_column=u'Z_SUPER',
blank=True)
z_max = models.IntegerField(
null=True,
db_column=u'Z_MAX',
blank=True)
class Meta(PathCoreMetaDatum.Meta):
db_table = u'Z_PRIMARYKEY'
ordering = ['z_ent', 'z_super', 'z_name']
# watson registration
import watson
for model in coredata_models:
watson.register(model, adapter_cls=model.adapter())
watson.register(MetaData)
tag_register(Endpoint) tag_register(Finding_Template) admin.site.register(Test) admin.site.register(Finding) admin.site.register(FindingImage) admin.site.register(FindingImageAccessToken) admin.site.register(Stub_Finding) admin.site.register(Engagement) admin.site.register(Risk_Acceptance) admin.site.register(Check_List) admin.site.register(Test_Type) admin.site.register(Endpoint) admin.site.register(Product) admin.site.register(Dojo_User) admin.site.register(UserContactInfo) admin.site.register(Notes) admin.site.register(Report) admin.site.register(Scan) admin.site.register(ScanSettings) admin.site.register(IPScan) admin.site.register(Alerts) admin.site.register(JIRA_Issue) admin.site.register(Tool_Configuration) admin.site.register(Tool_Product_Settings) admin.site.register(Tool_Type) watson.register(Product) watson.register(Test) watson.register(Finding)
location = models.CharField(max_length=200)
match_date = models.DateField()
merge_flag = models.CharField(max_length=500)
map_location = models.CharField(max_length=500)
highlight_url = models.CharField(max_length=500)
def get_absolute_url(self):
return "/matches/%d/" % self.match_num
def __str__(self):
return self.country_A.country_name + " " + self.country_B.country_name + " " + self.score
import watson
"""
This is where the models are registered. Only the text fields can be registered or else and error will
occur.
"""
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"))
# watson.register(Country)
# watson.register(Player)
# watson.register(Match)
def ready(self):
post = self.get_model("post")
watson.register(post)
from rsssync.models import RssEntry import watson watson.register(RssEntry)
def __unicode__(self):
return '%s' % (self.name)
def get_CategoryList(self):
self.categorylist = NoteCategory.objects.all()
return self.categorylist
class Note(models.Model):
title = models.CharField(max_length=110)
body = RichTextField(config_name='default')
data_pub = models.DateTimeField()
published = models.BooleanField(default=False)
name = models.CharField(max_length=110)
category = models.ForeignKey(NoteCategory)
def __unicode__(self):
return '%s' % (self.name)
def get_NoteList(self): # full note list, avalilabled for publish
self.note_list = Note.objects.filter(published=True)
return self.note_list
def get_absolute_url(self):
return reverse('blog.views.show_blog', args=[str(self.id)])
import watson # search engine https://github.com/etianen/django-watson/wiki
watson.register(Note)
watson.register(NoteCategory)
body = ImageWithThumbsField(upload_to=GALLERY_CONFIGS['DIR'],
sizes=(GALLERY_CONFIGS['IMAGE_MAX_SIZE'],
GALLERY_CONFIGS['THUMBNAIL_MAX_SIZE'],
)
)
# thumbnail_url = body.url[:-4] + 'url_' \
# + str(GALLERY_CONFIGS['THUMBNAIL_MAX_SIZE'][0]) \
# + 'x' \
# + str(GALLERY_CONFIGS['THUMBNAIL_MAX_SIZE'][1]) \
# + body.url[:-4]
name = models.CharField(max_length=80)
# path = models.FilePathField()
tags = models.ManyToManyField(ImageTag)
published = models.BooleanField(default=False)
sort_order = models.IntegerField(default=0)
def get_absolute_url(self):
return reverse('gallery.views.show_image', args=[str(self.id)])
def __unicode__(self): # Python 3: def __str__(self):
return self.name
import watson
watson.register(Image)
watson.register(ImageCategory)
primary_location = models.CharField(max_length=200, blank=True)
other_locations = models.CharField(max_length=200, blank=True)
start_time = models.DateField(null=True, blank=True)
end_time = models.DateField(null=True, blank=True)
class Honor(models.Model):
user = models.ForeignKey(McUser, related_name='honors')
title = models.CharField(max_length=200, blank=True)
received_time = models.DateField(null=True, blank=True)
class City(models.Model):
real_name = models.CharField(max_length=200, blank=True)
norm_name = models.CharField(max_length=200, blank=True)
lat = models.FloatField(blank=True, null=True)
lng = models.FloatField(blank=True, null=True)
watson.register(McUser,
fields=('first_name', 'last_name', 'gender', 'class_year',
'hometown', 'hometown_state', 'high_school',
'norm_name', 'staff_title', 'maiden_name',
'current_city'))
watson.register(Degree)
watson.register(Experience)
watson.register(StudyAbroad)
watson.register(Honor)
# at bottom for circular dependency
import signals
class Question(models.Model):
PENDING = 0
ANSWERED = 1
REJECTED = 2
questioner = models.ForeignKey(User, null=True, blank=True,
related_name='questioner')
meta = models.ForeignKey(QuestionMeta)
questionee = models.ForeignKey(User, related_name='questionee')
is_anonymouse = models.BooleanField(default=False)
answer = models.ForeignKey('story.Story', related_name='answer',
null=True, blank=True)
created_at = models.DateTimeField(auto_now_add=True)
status = models.PositiveSmallIntegerField(
default=0, choices=((PENDING, 'Pending'),
(ANSWERED, 'Answered'),
(REJECTED, 'Rejected')))
def __unicode__(self):
return '%s - %s -> %s' % (self.questioner, self.meta.text,
self.questionee)
def post_answer_url(self):
return '%s?qid=%s' % (
reverse('create-story', kwargs={
'base62_id': self.meta.base62_id}), self.id)
watson.register(QuestionMeta, store=("text", "answer_count", "base62_id"))
else:
self.machine_name = self.title + u' (αντ. 1)'
self.slug = uuslug(self.title, instance=self)
super(Item, self).save()
def get_absolute_url(self):
return ('bookshelf_itemdetail_view', (), {'slug': self.slug})
get_absolute_url = models.permalink(get_absolute_url)
def get_book_authors(self):
return ', '.join(author.name for author in self.author.all())
def get_authors(self):
return ', '.join([a.name for a in self.author.all()])
get_authors.short_description = AUTHOR_PL
def get_editors(self):
return ', '.join([a.name for a in self.editor.all()])
def get_publishers(self):
return ', '.join([p.name for p in self.publisher.objects.all()])
def clean(self):
if self.num_available_copies > self.num_copies:
raise ValidationError(ITEM_VAL_ERR)
watson.register(Author)
watson.register(Item)
if self.authors.count() > 1:
for author in self.authors.all():
link = link + '<span><a href="' + author.get_absolute_url(
) + '">' + author.name + '</a></span>'
else:
for author in self.authors.all():
link = link + '<span><a href="' + author.get_absolute_url(
) + '">' + author.name + '</a></span>'
if not link:
link = u'<span>%s</span>' % self.author_name
return link
@permalink
def get_absolute_url(self):
return ('view_blog_post', None, {'slug': self.slug})
class Category(models.Model):
title = models.CharField(max_length=100, db_index=True)
slug = models.SlugField(max_length=100, db_index=True)
def __unicode__(self):
return '%s' % self.title
@permalink
def get_absolute_url(self):
return ('view_blog_category', None, {'slug': self.slug})
watson.register(Blog)
watson.register(Author)
post_save.connect(add_to_preview, sender=User) post_save.connect(add_content, sender=Tutorial) post_save.connect(add_content, sender=Snippet) post_save.connect(add_content, sender=Wiki) post_save.connect(add_content, sender=Announcement) post_save.connect(add_content, sender=News) post_save.connect(add_content, sender=Blog) post_save.connect(add_content, sender=Event) post_save.connect(add_content, sender=EducationalResource) post_save.connect(add_content, sender=Package) secretballot.enable_voting_on(Tutorial) secretballot.enable_voting_on(Snippet) secretballot.enable_voting_on(Wiki) secretballot.enable_voting_on(Announcement) secretballot.enable_voting_on(News) secretballot.enable_voting_on(Blog) secretballot.enable_voting_on(Event) secretballot.enable_voting_on(EducationalResource) secretballot.enable_voting_on(Package) watson.register(Tutorial) watson.register(Snippet) watson.register(Wiki) watson.register(Announcement) watson.register(News) watson.register(Blog) watson.register(EducationalResource) watson.register(Package) watson.register(Event)
'url': reverse('view_risk', args=(self.engagement_set.first().product.id, self.id,))}]
return bc
# Register for automatic logging to database
auditlog.register(Dojo_User)
auditlog.register(Endpoint)
auditlog.register(Engagement)
auditlog.register(Finding)
auditlog.register(Product)
auditlog.register(Test)
auditlog.register(Risk_Acceptance)
admin.site.register(Test)
admin.site.register(Finding)
admin.site.register(Stub_Finding)
admin.site.register(Engagement)
admin.site.register(Risk_Acceptance)
admin.site.register(Check_List)
admin.site.register(Test_Type)
admin.site.register(Endpoint)
admin.site.register(Product)
admin.site.register(Dojo_User)
admin.site.register(Notes)
admin.site.register(Scan)
admin.site.register(ScanSettings)
watson.register(Product)
watson.register(Test)
watson.register(Finding)
@type language: models.CharField(200)
@cvar language: Most common language spoken in this culture
@type related_figures: models.ManyToManyField('Figure')
@cvar related_figures: Many to many assocation associating Figures related to this Culture
@type related_cultures: models.ManyToManyField('self')
@cvar related_cultures: Many to many assocation associating Cultures similar to this Culture
@type related_stories: models.ManyToManyField('Story')
@cvar related_stories: Many to many assocation associating notable mythological stories belonging within this Culture
'''
name = models.CharField(max_length=200)
region = models.CharField(max_length=200)
history = models.CharField(max_length=10000)
language = models.CharField(max_length=200)
related_cultures = models.ManyToManyField('self')
def get_absolute_url(self):
return "/cultures/%i/" % self.id
def __unicode__(self):
return self.name
# -----
# Watson
# -----
import watson
watson.register(Figure)
watson.register(Culture)
watson.register(Story)
def ready(self):
Story = self.get_model('Story')
watson.register(Story.objects.published())
post_save.connect(add_to_preview,sender=User) post_save.connect(add_content,sender=Tutorial) post_save.connect(add_content,sender=Snippet) post_save.connect(add_content,sender=Wiki) post_save.connect(add_content,sender=Announcement) post_save.connect(add_content,sender=News) post_save.connect(add_content,sender=Blog) post_save.connect(add_content,sender=Event) post_save.connect(add_content,sender=EducationalResource) post_save.connect(add_content,sender=Package) secretballot.enable_voting_on(Tutorial) secretballot.enable_voting_on(Snippet) secretballot.enable_voting_on(Wiki) secretballot.enable_voting_on(Announcement) secretballot.enable_voting_on(News) secretballot.enable_voting_on(Blog) secretballot.enable_voting_on(Event) secretballot.enable_voting_on(EducationalResource) secretballot.enable_voting_on(Package) watson.register(Tutorial) watson.register(Snippet) watson.register(Wiki) watson.register(Announcement) watson.register(News) watson.register(Blog) watson.register(EducationalResource) watson.register(Package) watson.register(Event)
@property
def get_image(self):
"""
Returns the default image field
"""
return self.image
class Comment(models.Model):
author = models.CharField(max_length=100)
email = models.CharField(max_length=200)
content = models.TextField()
created = models.DateTimeField(auto_now_add=True)
article = models.ForeignKey(Article)
def __unicode__(self):
return self.article.title
# class Comment(Comment):
# article = models.ForeignKey(Article, blank=False, )
# content = models.CharField(max_length=300)
# def get_comment_model(self):
# # Use our custom comment model instead of the built-in one.
# return Comment
if 'watson' in settings.INSTALLED_APPS:
import watson
watson.register(Article)
@property
def get_image(self):
"""
Returns the default image field
"""
return self.image
class Comment(models.Model):
author = models.CharField(max_length=100)
email = models.CharField(max_length=200)
content = models.TextField()
created = models.DateTimeField(auto_now_add=True)
article = models.ForeignKey(Article)
def __unicode__(self):
return self.article.title
# class Comment(Comment):
# article = models.ForeignKey(Article, blank=False, )
# content = models.CharField(max_length=300)
# def get_comment_model(self):
# # Use our custom comment model instead of the built-in one.
# return Comment
if 'watson' in settings.INSTALLED_APPS:
import watson
watson.register(Article)
extra = 0
class ProjectAdmin(admin.ModelAdmin):
actions = [admin.site.get_action('delete_selected')]
fields = ['project_user', 'project_name', 'project_is_dark', 'project_menu_is_horizontal']
inlines = [ProjectInline]
class GalleryAdmin(admin.ModelAdmin):
actions = [admin.site.get_action('delete_selected')]
fields = ['user', 'image']
class UserProfileAdmin(UserAdmin):
def delete_model(self, request, obj):
if type(obj) == User and obj == request.user:
print('asdasdas')
return False
else:
obj.delete()
admin.site.register(Project, ProjectAdmin)
admin.site.register(Gallery, GalleryAdmin)
admin.site.unregister(User)
admin.site.register(User, UserProfileAdmin)
watson.register(Project,fields=("project_name",))
watson.register(PageProject, fields=("page_name","text",))
watson.register(User, fields=("username",))
@staticmethod
def add(user, work):
pt = PersonalTop.objects.filter(user=user)
if pt.filter(work=work).count() == 0:
PersonalTop(user=user, work=work, position=pt.count() + 1).save()
return True
else:
return False
def move_up(self):
if self.position == 1:
return
prev = PersonalTop.objects.get(user=self.user, position=self.position-1)
prev.position = self.position
prev.save()
self.position = self.position-1
self.save()
def move_down(self):
if self.position == PersonalTop.objects.filter(user=self.user).count():
return
next = PersonalTop.objects.get(user=self.user, position=self.position+1)
next.position = self.position
next.save()
self.position = self.position+1
self.save()
watson.register(Review, fields=('name','text',))
watson.register(Comment, fields=('text',))
def ready(self):
Image = self.get_model("Image")
watson.register(Image,
fields=('tags__name', ),
store=('thumbnail__url', 'page_url', 'source_url',
'get_origin_display', 'tags__name'))
