1

I wasn't sure how to word this exactly. But I have a model that lists a bunch of stores (complete with name, address, phone, etc). I also want to list and store links attributed to the store, so like say a Yelp Review, Yellowpages link, etc.

Instead of constantly adding columns, I was kind of thinking having a different model that lists a bunch of types of "link sources" like Yelp, Yellowpages, etc. and then another that actually cross references them so a row will have like store id 3, has a link at link type yelp.

Any ideas how I would accomplish this so an admin can dynamically add another link type, like say Google Places, and then will be able to add a link to a store's Google Places page to a store?

Improve this question

2 Answers 2

Reset to default
3

You basically have two options based on what kind of relationship you want to model with your 'references':

  1. models.ForeignKey (if the model with the ForeignKey should have a link to exactly one model of a specific type in another django model) or models.ManyToManyField (if its a many to many relationship).
  2. Use the contenttypes framework, which allows you to essentially have a generic foreignkey; https://docs.djangoproject.com/en/dev/ref/contrib/contenttypes/

This is a bit abstract, so I'll give a concrete example of each option.

Say you have a Store model, where each store contains at most one review, but the same review can point to multiple stores. Then it may make sense to have a model like this:

class Store(models.Model):
    name = models.CharField(max_length=50)
    review = models.ForeignKey('Review')

class Review(models.Model):
    user_comment = models.TextField(max_length=1024)

As written above you could have Stores A, B, C, where store A and store B both link to review 1, and store C links to review 2. This seems a bit silly; a review of a store should only point to one store (and you should be allowed to have stores with no reviews or multiple reviews; but shouldn't be able to have a review that doesn't point to a store). So it makes much more sense to construct it like:

class Store(models.Model):
    name = models.CharField(max_length=50)

class Review(models.Model):
    user_comment = models.TextField(max_length=1024)
    store = models.ForeignKey('Store')

This way each review points to exactly one store; but a store doesn't necessarily have a review. If you have a variable store_obj with an instance of a specific store you can iterate through all the reviews with by the queryset store_obj.review_set.all().

Now lets say you have two models say Store and Hotel that are fundamentally different, but want only one review class to link to both. This is where contenttypes / GenericRelation come in. Its a bit more complicated than simple ForeignKey (as you have to keep track of the type and object_id and then construct the GenericForeignKey), but could be implemented as follows. (Obviously this would only make sense if you really need different fields/methods in Hotel and Store, unlike this example.)

from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes import generic

class Store(models.Model):
    name = models.CharField(max_length=50)
    reviews = generic.GenericRelation("GenericReview")

class Hotel(models.Model):
    name = models.CharField(max_length=50)
    reviews = generic.GenericRelation("GenericReview")

class GenericReview(models.Model):
    text = models.TextField(max_length=1024)
    content_type = models.ForeignKey(ContentType)
    object_id = models.PositiveIntegerField()
    content_object = generic.GenericForeignKey('content_type', 'object_id')

Actually upon re-reading your answer I think what you want is just something like:

class Store(models.Model):
    name = models.CharField(max_length=50)

class Review(models.Model):
    user_comment = models.TextField(max_length=1024)
    review_type = models.CharField(max_length=4, choices=(('yelp', 'Yelp'), ('ypag', 'Yellow Pages'),)) 
    hyperlink = models.URLField()
    store = models.ForeignKey('Store')

So each review is linked to one store, you can give a list of choices to be stored in the database 'yelp', 'ypag' represented by longer text strings, as well as the hyperlink.

You could also create separate classes for each type of review if they are fundamentally different; e.g., if you were doing movie reviews a rotten tomatoes review would store fundamentally different information than a metacritic review. But it doesn't matter as long as each model has a FK pointing back to Store.

If you need the admin to edit the list of review-types, the way to do it is as a foreignkey. Something like:

class Store(models.Model):
    name = models.CharField(max_length=50)
class ReviewType(models.Model):
    def __unicode__(self):
        return u'%s' % (self.description)
    description = models.CharField(max_length=50)
class Review(models.Model):
    user_comment = models.TextField(max_length=1024)
    review_type = models.ForeignKey("ReviewType")
    hyperlink = models.URLField()
    store = models.ForeignKey('Store')
ReviewType.objects.get_or_create(id=1, defaults=dict(description="Yelp"))
ReviewType.objects.get_or_create(id=2, defaults=dict(description="Yellow Pages"))

As you knew you'd have some initial ReviewType objects, I used get_or_create to create them based on id (on id, so if an admin edits the name "Yellow Pages" to say "Yellowpages" a new object is never created).

To make it so you can add a review from the admin page of the Store, you need to use inline models: https://docs.djangoproject.com/en/1.3/ref/contrib/admin/#django.contrib.admin.InlineModelAdmin

So on your admin.py page, do something like

class ReviewInline(admin.TabularInline):
    model = review
    extra = 1

class StoreAdmin(admin.ModelAdmin):
    inlines = [ReviewInline,]

admin.site.register(Store, StoreAdmin)
Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

I think contenttypes is closer to what I'm trying to achieve. It's closer to the idea of tagging, since in a sense I will be "tagging" a model with a particular tag, but it will also have a unique link associated with the tag and the model.
@xtine: Ok, so i finally finished my answer. (I submitted it without the code as it had the gist of the answer and I didn't want to be beaten to the punch by someone else; but think the code makes it quite concrete.)
The "choices" selection is what I need. However, I was thinking of having the choices being adminable so an admin could add another link type without having me to add it in the model.
@xtine: If you need the choices to be adminable, you need to have the review_type as a ForeignKey to a review_type class.
Thank you so much for your help. I'll try to do this and let you know how it goes. :)
|
0

So what you want is a Store model, and you want each store to have one or more links that point to some information about the store. You can either use a ForeignKey or a ManyToManyField.

If each store has a unique set of links, then use ForeignKey. However, if stores Share links between them, then use a ManyToManyField. Most likely you will end up using a ForeignKey which means you should have something similar to the code below.

class Store(models.Model):
    name    = models.CharField()
    address = models.CharField()
    phone   = models.CharField()

class LinkType(models.Model)
    name = models.charField()

class Link(models.Model):
    name    = models.CharField()
    url     = models.CharField()
    type    = models.ForeignKey(LinkType) # Assumed links have only one type
    store   = models.ForeignKey(Store) # Assumed link each link belongs to only one store
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.