home

from django.db import models

# Cards: Describes a card that will be loaded in the main page, providing links to useful information and other apps.

class Card(models.Model):

    title = models.CharField(max_length=20) # 20 should sustain well.

    description = models.CharField(max_length=256) # 256 as well.

    link1 = models.CharField('First link', blank=True, max_length=50) # I could make this a URLField, but that doesn't accept cases like "/ITdays".

    linkName1 = models.CharField('Name of first link', blank=True, max_length=20)

    link2 = models.CharField('Second link', blank=True, max_length=50) # This may be empty.

    linkName2 = models.CharField('Name of second link', blank=True, max_length=20) # This too.

    image = models.ImageField(upload_to='about/images/cards', blank=True) # Sometimes the cards should get an image.

    def __str__(self):

        return self.title

# What you're about to see, is a very rare case of where multi-level inheritance

# is actually done correctly. Notes should be taken. (Also worth mentioning

# Django is so well built it actually makes this possible.)

# First, it should be said all objects have an extremely similar structure. That

# doesn't qualify them yet for multilevel inheritance, but it's a good sign.

# Also, note how Card, even though it has both title and description, is NOT

# inherited from this base class. This is deliberate; Card is not an object with

# a comparable behavior, and thus, differs too much as an object to derive from

# this one.

class Subject(models.Model):

    """ This class should not be instantiated. Look at it as being an abstract

    class. """

    title = models.CharField(max_length=50)

    description = models.TextField()

    def __str__(self):

        return self.title

    """ This Meta is important, because it tells Django that Subject is

    'abstract', in that it just has some fields that should be passed to its

    children. """

    class Meta:

        abstract = True

# Now you may say: Well, some subjects have links, why not make another object,

# and use it for just that? Well, because that would imply multiple inheritance,

# which is not necessary here*, and (if that second object would inherit Model

# again) cause a diamond inheritance.

# *Most of the time people use inheritance because it's convenient. While that

# may be a reason, it shouldn't be the only reason for it. Inheritance is not

# made to make programming convenient, that's what programming languages are

# for. Inheritance is to inherit behavior from another object. And since that's

# my goal here, inheritance is a passable programming decision.

# Also, I'm referring here to OOP inheritance, which means "inheriting state AND

# behavior". Languages that implement other paradigms can also have inheritance.

# Clojure, for example, is not OOP, but fully functional, and its inheritance

# capabilities are WAY better.

class Product(models.Model):

    name = models.CharField(max_length=128)

    estimated_price = models.PositiveSmallIntegerField(null=False)

    picture = models.URLField(blank=True)

    url = models.URLField(blank=True)

    isbn = models.CharField(max_length=13, blank=True)

    jonathan = models.BooleanField()

    maarten = models.BooleanField()

    extra_info = models.TextField(blank=True)

    purchaser = models.GenericIPAddressField(blank=True,null=True)

    def __str__(self):

        return self.name

class Principle(Subject):

    pass

class AboutMe(Subject):

    pass

class Program(Subject):

    link = models.URLField()

class Stack(Subject):

    link = models.URLField()

class Hack(Subject):

    pass

class SecurityMeasure(Subject):

    pass

class Goal(Subject):

    pass

# A last pick on inheritance (I feel so obliged to defend my decision because I

# decided to use inheritance, apologies if you're sick of taking notes):

# Note that I could've easily solved this problem without inheritance. Some

# objects even lack any other variable or function of some sort.

# But also, note how easy it now becomes to edit all those objects at once: If I

# want to increase the length (And yes, that length should be the same, I like

# that), I can now do that all at once. THIS is when inheritance can be a good

# thing: To increase code maintainability for a lot of different objects.

class Quote(models.Model):

    text = models.TextField()

    author = models.CharField(max_length=256)

    link = models.URLField(blank=True)

# Really, these max_lengths... Sometimes I look at my code and just think what an arbitrary asshole I can be to my database.