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): 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 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 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 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)
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)
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'))