import datetime

import os

import tempfile

import uuid

from django.core import validators

from django.core.exceptions import ValidationError

from django.core.files.storage import FileSystemStorage

from django.db import models

temp_storage_dir = tempfile.mkdtemp()

temp_storage = FileSystemStorage(temp_storage_dir)

class Person(models.Model):

    name = models.CharField(max_length=100)

class Category(models.Model):

    name = models.CharField(max_length=20)

    slug = models.SlugField(max_length=20)

    url = models.CharField("The URL", max_length=40)

    class Meta:

        ordering = ("pk",)

    def __str__(self):

        return self.name

    def __repr__(self):

        return self.__str__()

class WriterManager(models.Manager):

    def get_queryset(self):

        qs = super().get_queryset()

        return qs.filter(archived=False)

class Writer(models.Model):

    name = models.CharField(max_length=50, help_text="Use both first and last names.")

    archived = models.BooleanField(default=False, editable=False)

    objects = WriterManager()

    class Meta:

        ordering = ("name",)

    def __str__(self):

        return self.name

class Article(models.Model):

    ARTICLE_STATUS = (

        (1, "Draft"),

        (2, "Pending"),

        (3, "Live"),

    )

    headline = models.CharField(max_length=50)

    slug = models.SlugField()

    pub_date = models.DateField()

    created = models.DateField(editable=False)

    writer = models.ForeignKey(Writer, models.CASCADE)

    article = models.TextField()

    categories = models.ManyToManyField(Category, blank=True)

    status = models.PositiveIntegerField(choices=ARTICLE_STATUS, blank=True, null=True)

    def save(self, *args, **kwargs):

        if not self.id:

            self.created = datetime.date.today()

        return super().save(*args, **kwargs)

    def __str__(self):

        return self.headline

class ImprovedArticle(models.Model):

    article = models.OneToOneField(Article, models.CASCADE)

class ImprovedArticleWithParentLink(models.Model):

    article = models.OneToOneField(Article, models.CASCADE, parent_link=True)

class BetterWriter(Writer):

    score = models.IntegerField()

class Publication(models.Model):

    title = models.CharField(max_length=30)

    date_published = models.DateField()

    def __str__(self):

        return self.title

def default_mode():

    return "di"

def default_category():

    return 3

class PublicationDefaults(models.Model):

    MODE_CHOICES = (("di", "direct"), ("de", "delayed"))

    CATEGORY_CHOICES = ((1, "Games"), (2, "Comics"), (3, "Novel"))

    title = models.CharField(max_length=30)

    date_published = models.DateField(default=datetime.date.today)

    datetime_published = models.DateTimeField(default=datetime.datetime(2000, 1, 1))

    mode = models.CharField(max_length=2, choices=MODE_CHOICES, default=default_mode)

    category = models.IntegerField(choices=CATEGORY_CHOICES, default=default_category)

    active = models.BooleanField(default=True)

    file = models.FileField(default="default.txt")

class Author(models.Model):

    publication = models.OneToOneField(

        Publication, models.SET_NULL, null=True, blank=True

    )

    full_name = models.CharField(max_length=255)

class Author1(models.Model):

    publication = models.OneToOneField(Publication, models.CASCADE, null=False)

    full_name = models.CharField(max_length=255)

class WriterProfile(models.Model):

    writer = models.OneToOneField(Writer, models.CASCADE, primary_key=True)

    age = models.PositiveIntegerField()

    def __str__(self):

        return "%s is %s" % (self.writer, self.age)

class Document(models.Model):

    myfile = models.FileField(upload_to="unused", blank=True)

class TextFile(models.Model):

    description = models.CharField(max_length=20)

    file = models.FileField(storage=temp_storage, upload_to="tests", max_length=15)

    def __str__(self):

        return self.description

class CustomFileField(models.FileField):

    def save_form_data(self, instance, data):

        been_here = getattr(self, "been_saved", False)

        assert not been_here, "save_form_data called more than once"

        setattr(self, "been_saved", True)

class CustomFF(models.Model):

    f = CustomFileField(upload_to="unused", blank=True)

class FilePathModel(models.Model):

    path = models.FilePathField(

        path=os.path.dirname(__file__), match="models.py", blank=True

    )

try:

    from PIL import Image  # NOQA: detect if Pillow is installed

    test_images = True

    class ImageFile(models.Model):

        def custom_upload_path(self, filename):

            path = self.path or "tests"

            return "%s/%s" % (path, filename)

        description = models.CharField(max_length=20)

        # Deliberately put the image field *after* the width/height fields to

        # trigger the bug in #10404 with width/height not getting assigned.

        width = models.IntegerField(editable=False)

        height = models.IntegerField(editable=False)

        image = models.ImageField(

            storage=temp_storage,

            upload_to=custom_upload_path,

            width_field="width",

            height_field="height",

        )

        path = models.CharField(max_length=16, blank=True, default="")

        def __str__(self):

            return self.description

    class OptionalImageFile(models.Model):

        def custom_upload_path(self, filename):

            path = self.path or "tests"

            return "%s/%s" % (path, filename)

        description = models.CharField(max_length=20)

        image = models.ImageField(

            storage=temp_storage,

            upload_to=custom_upload_path,

            width_field="width",

            height_field="height",

            blank=True,

            null=True,

        )

        width = models.IntegerField(editable=False, null=True)

        height = models.IntegerField(editable=False, null=True)

        path = models.CharField(max_length=16, blank=True, default="")

        def __str__(self):

            return self.description

    class NoExtensionImageFile(models.Model):

        def upload_to(self, filename):

            return "tests/no_extension"

        description = models.CharField(max_length=20)

        image = models.ImageField(storage=temp_storage, upload_to=upload_to)

        def __str__(self):

            return self.description

except ImportError:

    test_images = False

class Homepage(models.Model):

    url = models.URLField()

class Product(models.Model):

    slug = models.SlugField(unique=True)

    def __str__(self):

        return self.slug

class Price(models.Model):

    price = models.DecimalField(max_digits=10, decimal_places=2)

    quantity = models.PositiveIntegerField()

    class Meta:

        unique_together = (("price", "quantity"),)

    def __str__(self):

        return "%s for %s" % (self.quantity, self.price)

class Triple(models.Model):

    left = models.IntegerField()

    middle = models.IntegerField()

    right = models.IntegerField()

    class Meta:

        unique_together = (("left", "middle"), ("middle", "right"))

class ArticleStatus(models.Model):

    ARTICLE_STATUS_CHAR = (

        ("d", "Draft"),

        ("p", "Pending"),

        ("l", "Live"),

    )

    status = models.CharField(

        max_length=2, choices=ARTICLE_STATUS_CHAR, blank=True, null=True

    )

class Inventory(models.Model):

    barcode = models.PositiveIntegerField(unique=True)

    parent = models.ForeignKey(

        "self", models.SET_NULL, to_field="barcode", blank=True, null=True

    )

    name = models.CharField(blank=False, max_length=20)

    class Meta:

        ordering = ("name",)

    def __str__(self):

        return self.name

    def __repr__(self):

        return self.__str__()

class Book(models.Model):

    title = models.CharField(max_length=40)

    author = models.ForeignKey(Writer, models.SET_NULL, blank=True, null=True)

    special_id = models.IntegerField(blank=True, null=True, unique=True)

    class Meta:

        unique_together = ("title", "author")

class BookXtra(models.Model):

    isbn = models.CharField(max_length=16, unique=True)

    suffix1 = models.IntegerField(blank=True, default=0)

    suffix2 = models.IntegerField(blank=True, default=0)

    class Meta:

        unique_together = ("suffix1", "suffix2")

        abstract = True

class DerivedBook(Book, BookXtra):

    pass

class ExplicitPK(models.Model):

    key = models.CharField(max_length=20, primary_key=True)

    desc = models.CharField(max_length=20, blank=True, unique=True)

    class Meta:

        unique_together = ("key", "desc")

    def __str__(self):

        return self.key

class Post(models.Model):

    title = models.CharField(max_length=50, unique_for_date="posted", blank=True)

    slug = models.CharField(max_length=50, unique_for_year="posted", blank=True)

    subtitle = models.CharField(max_length=50, unique_for_month="posted", blank=True)

    posted = models.DateField()

    def __str__(self):

        return self.title

class DateTimePost(models.Model):

    title = models.CharField(max_length=50, unique_for_date="posted", blank=True)

    slug = models.CharField(max_length=50, unique_for_year="posted", blank=True)

    subtitle = models.CharField(max_length=50, unique_for_month="posted", blank=True)

    posted = models.DateTimeField(editable=False)

    def __str__(self):

        return self.title

class DerivedPost(Post):

    pass

class BigInt(models.Model):

    biggie = models.BigIntegerField()

    def __str__(self):

        return str(self.biggie)

class MarkupField(models.CharField):

    def __init__(self, *args, **kwargs):

        kwargs["max_length"] = 20

        super().__init__(*args, **kwargs)

    def formfield(self, **kwargs):

        # don't allow this field to be used in form (real use-case might be

        # that you know the markup will always be X, but it is among an app

        # that allows the user to say it could be something else)

        # regressed at r10062

        return None

class CustomFieldForExclusionModel(models.Model):

    name = models.CharField(max_length=10)

    markup = MarkupField()

class FlexibleDatePost(models.Model):

    title = models.CharField(max_length=50, unique_for_date="posted", blank=True)

    slug = models.CharField(max_length=50, unique_for_year="posted", blank=True)

    subtitle = models.CharField(max_length=50, unique_for_month="posted", blank=True)

    posted = models.DateField(blank=True, null=True)

class Colour(models.Model):

    name = models.CharField(max_length=50)

    def __iter__(self):

        yield from range(5)

    def __str__(self):

        return self.name

class ColourfulItem(models.Model):

    name = models.CharField(max_length=50)

    colours = models.ManyToManyField(Colour)

class CustomErrorMessage(models.Model):

    name1 = models.CharField(

        max_length=50,

        validators=[validators.validate_slug],

        error_messages={"invalid": "Model custom error message."},

    )

    name2 = models.CharField(

        max_length=50,

        validators=[validators.validate_slug],

        error_messages={"invalid": "Model custom error message."},

    )

    def clean(self):

        if self.name1 == "FORBIDDEN_VALUE":

            raise ValidationError(

                {"name1": [ValidationError("Model.clean() error messages.")]}

            )

        elif self.name1 == "FORBIDDEN_VALUE2":

            raise ValidationError(

                {"name1": "Model.clean() error messages (simpler syntax)."}

            )

        elif self.name1 == "GLOBAL_ERROR":

            raise ValidationError("Global error message.")

def today_callable_dict():

    return {"last_action__gte": datetime.datetime.today()}

def today_callable_q():

    return models.Q(last_action__gte=datetime.datetime.today())

class Character(models.Model):

    username = models.CharField(max_length=100)

    last_action = models.DateTimeField()

    def __str__(self):

        return self.username

class StumpJoke(models.Model):

    most_recently_fooled = models.ForeignKey(

        Character,

        models.CASCADE,

        limit_choices_to=today_callable_dict,

        related_name="jokes",

    )

    has_fooled_today = models.ManyToManyField(

        Character,

        limit_choices_to=today_callable_q,

        related_name="jokes_today",

    )

    funny = models.BooleanField(default=False)

# Model for #13776

class Student(models.Model):

    character = models.ForeignKey(Character, models.CASCADE)

    study = models.CharField(max_length=30)

# Model for #639

class Photo(models.Model):

    title = models.CharField(max_length=30)

    image = models.FileField(storage=temp_storage, upload_to="tests")

    # Support code for the tests; this keeps track of how many times save()

    # gets called on each instance.

    def __init__(self, *args, **kwargs):

        super().__init__(*args, **kwargs)

        self._savecount = 0

    def save(self, force_insert=False, force_update=False):

        super().save(force_insert, force_update)

        self._savecount += 1

class UUIDPK(models.Model):

    uuid = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)

    name = models.CharField(max_length=30)

# Models for #24706

class StrictAssignmentFieldSpecific(models.Model):

    title = models.CharField(max_length=30)

    _should_error = False

    def __setattr__(self, key, value):

        if self._should_error is True:

            raise ValidationError(message={key: "Cannot set attribute"}, code="invalid")

        super().__setattr__(key, value)

class StrictAssignmentAll(models.Model):

    title = models.CharField(max_length=30)

    _should_error = False

    def __setattr__(self, key, value):

        if self._should_error is True:

            raise ValidationError(message="Cannot set attribute", code="invalid")

        super().__setattr__(key, value)

# A model with ForeignKey(blank=False, null=True)

class Award(models.Model):

    name = models.CharField(max_length=30)

    character = models.ForeignKey(Character, models.SET_NULL, blank=False, null=True)

class NullableUniqueCharFieldModel(models.Model):

    codename = models.CharField(max_length=50, blank=True, null=True, unique=True)

    email = models.EmailField(blank=True, null=True)

    slug = models.SlugField(blank=True, null=True)

    url = models.URLField(blank=True, null=True)

class Number(models.Model):

    value = models.IntegerField()

class NumbersToDice(models.Model):

    number = models.ForeignKey("Number", on_delete=models.CASCADE)

    die = models.ForeignKey("Dice", on_delete=models.CASCADE)

class Dice(models.Model):

    numbers = models.ManyToManyField(

        Number,

        through=NumbersToDice,

        limit_choices_to=models.Q(value__gte=1),

    )