joeni

from django.db import models

from django.utils.translation import ugettext_lazy as _

from joeni import constants

def validate_hex_color(value):

    pass  # TODO

class Account(models.Model):

    user = models.OneToOneField(

        'administration.User',

        on_delete=models.CASCADE,

        primary_key=True,

        )

    alias = models.CharField(max_length=64, unique=True)

    def __str__(self):

        return self.alias

def account_user_directory(instance, filename):

    return '{0}/account/settings/{1}'.format(instace.account.alias, filename)

class AccountSettings(models.Model):

    account = models.OneToOneField(

        'Account',

        on_delete=models.CASCADE,

        primary_key=True,

        )

    # TODO: Build validator for primary_color to make sure what is given is a

    # valid hexadecimal RGB value.

    color = models.CharField(

        max_length=6,

        help_text=_("The hexadecimal code of the color for this account."),

        default = constants.COLORS["UHasselt default"],

        blank=False,

        validators=[validate_hex_color],

        )

    account_page_banner = models.ImageField(  # Requires the Pillow library!

        upload_to=account_user_directory,

        help_text=_("The banner image to be shown on this account's homepage."),

        )

    avatar = models.ImageField(

        upload_to=account_user_directory,

        help_text=_("The avatar image of this account."),

        )

    def __str__(self):

        return str(self.account)

class Post(models.Model):

    timestamp = models.DateTimeField(auto_now_add=True)

    title = models.CharField(

        max_length=64,

        blank=True,

        help_text=_("The title for this post."),

        )

    text = models.TextField(

        blank=True,

        help_text=_("A text message for this post. May be left blank."),

        )

    author = models.ForeignKey(

        "Account",

        on_delete=models.CASCADE,

        null=False,  # There must be an author

        #editable=False,  # It makes no sense to change the author after creation

        help_text=_("The authoring account of this post."),

        )

    response_to = models.ForeignKey(

        "self",

        on_delete=models.CASCADE,

        null=True,  # If this is null, this post is not a response, but a beginning post

        #editable=False,  # This cannot be changed after creation, wouldn't make sense

        related_name="responses",

        help_text=_("The post to which this was a response, if applicable."),

        )

    placed_on = models.ForeignKey(

        "Page",

        on_delete=models.CASCADE,

        null=False,

        #editable=False,

        help_text=_("The page on which this post was placed."),

        )

    # Voting fields

    allow_votes = models.BooleanField(

        default=True,

        help_text=_("Decide whether to allow voting or disable it for this post."),

        )

    allow_responses = models.BooleanField(

        default=True,

        help_text=_("Decide if other people can respond to this post or not. "

                    "This does not influence what people allow on their posts."),

        )

    def votes(self):

        """ Return how many votes this post has. """

        return len(Vote.objects.filter(post=self))

    def __str__(self):

        return str(self.timestamp) + " | " + str(self.author)

    # TODO Add a way to attach geographical data to a post, which could

    # then be used with OpenStreetMap or something

class FilePost(Post):

    """ A special type of Post, which has a file linked with it.

    The poster can specify how to treat this file. """

    image = _("Image")

    video = _("Video")

    music = _("Sound")

    text  = _("Text" )

    other = _("Other")

    file = models.FileField(

        upload_to="agora/posts/%Y/%m/%d/",

        null=False,

        #editable=False,

        help_text=_("The file you wish to share."),

        )

    file_type = models.CharField(

        max_length=16,

        blank=False,

        choices = (

            ('image', image),

            ('video', video),

            ('music', music),

            ('text' , text ),

            ('other', other),

            ),

        help_text=_("How this file should be seen as."),

        )

class Page(models.Model):

    """ In the university, people can create pages for everything they want and

    then some. These pages are put in the database through this table. """

    name = models.CharField(

        max_length=64,

        primary_key=True,

        blank=False,

        help_text=_("The name of this page."),

        )

    created = models.DateTimeField(auto_now_add=True)

    hidden = models.BooleanField(

        default=False,

        help_text=_("Determines if this page can be found without a direct link."),

        )

    main_content = models.TextField(

        blank=True,

        help_text=_("If you want to put some text on this page, "

                    "you can put it here. You can use Orgmode-syntax to "

                    "get as much out of your page as possible. While doing so, "

                    "be aware of the limitations imposed by the code of conduct."),

        )

    public_posting = models.BooleanField(

        default=True,

        help_text=_("Determines if everyone can post on this page, or only the "

                    "people that are linked with it. Know that if a post is made "

                    "and responding is allowed, everyone can respond to that post."),

        )

    """class Meta:

        abstract=True"""

    """ I've disabled the abstraction, because otherwise I can't relate a Post to a Page. """

class AccountPage(Page):

    """ Every account has its own homepage. This is that page.

    This page can only be edited by the account holder, or staff members. """

    # TODO: Find a way to auto-create one of these every time a new account is created

    # TODO: Require that changes can only occur by either the account holder or staff

    account = models.OneToOneField(

        "Account",

        null=False,

        on_delete=models.CASCADE,

        )

class GroupPage(Page):

    """ A page where a group can present itself to the university.

    This page can only be edited by group members or staff members. """

    # TODO: Find a way to auto-create one of these every time a new group is created

    # TODO: Require that changes can only occur by either the group or staff

    group = models.ForeignKey(

        "Group",

        null=False,

        on_delete=models.CASCADE,

        )

class CoursePage(Page):

    """ A page that serves as a course's main entry point.

    This page can only be edited by the course's educating team or staff members. """

    # TODO: Find a way to auto-create one of these every time a new course is created

    # TODO: Require that changes can only occur by either the course team or staff

    course = models.OneToOneField(

        "courses.Course",

        null=False,

        on_delete=models.CASCADE,

        )

class Group(models.Model):

    """ It is imperative that everyone can come together with other people.

    A Group record is the way to accomplish this. """

    name = models.CharField(

        max_length=64,

        primary_key=True,  # So be unique I'd say

        blank=False,

        help_text=_("The name of your group."),

        )

    color = models.CharField(

        max_length=6,

        help_text=_("The hexadecimal code of the color for this group."),

        default = constants.COLORS["UHasselt default"],

        blank=False,

        validators=[validate_hex_color],

        )

    members = models.ManyToManyField(

        "Account",

        help_text=_("The members of this group."),

        )

    invite_only = models.BooleanField(

        default=True,

        help_text=_("Determines if everyone can join this group, or if "

                    "only members can invite others."),

        )

    private = models.BooleanField(

        default=True,

        help_text=_("Determines if this group is visible to non-members."),

        )

    def __str__(self):

        return self.name

class AccountCollection(models.Model):

    """ Every account can make a collection in which (s)he can list accounts

    at his/her wish. This can be a collection of Friends, study collegues,

    project partners, and so on.

    Accounts that are in a certain collection are not notified of this.

    However, there is one exception:

    If both accounts have a collection named "Friends" (or the localized

    equivalent), and both feature each other in that collection, then

    this is shared between the two accounts. """

    account = models.ForeignKey(

        "Account",

        null=False,

        #editable=False,

        on_delete=models.CASCADE,

        help_text=_("The account that created this collection."),

        )

    name = models.CharField(

        max_length=32,

        blank=False,

        help_text=_("The name of this collection."),

        )

    accounts = models.ManyToManyField(

        "Account",

        help_text=_("All accounts that are part of this collection."),

        related_name="in_collection",

        )

    visible_to_public = models.BooleanField(

        default=False,

        help_text=_("Make this collection visible to everybody."),

        )

    visible_to_collection = models.BooleanField(

        default=True,

        help_text=_("Make this collection visible to the accounts in this collection. Other collections are not affected by this."),

        )

    def __str__(self):

        return str(self.account) + " | " + self.name

class Vote(models.Model):

    """ Accounts can vote on posts (using ▲, which is funny because UHasselt).

    These votes are registered in this table. """

    voter = models.ForeignKey(

        "Account",

        null=False,

        #editable=False,

        on_delete=models.CASCADE,

        )

    post = models.ForeignKey(

        "Post",

        null=False,  # Duh.

        #editable=False,  # Transferring votes doesn't make sense

        on_delete=models.CASCADE,

        )

class SharedFile(models.Model):

    """ Groups and people can share files with each other, through a chat system.

    These files are represented here. """

    timestamp = models.DateTimeField(auto_now_add=True)

    file = models.FileField(

        upload_to="agora/chat/%Y/%m/%d/",

        null=False,

        #editable=False,

        help_text=_("The file you want to share."),

        )

    uploader = models.ForeignKey(

        "Account",

        on_delete=models.CASCADE,

        null=False,

        #editable=False,

        help_text=_("The account that uploaded this file."),

        )

    # TODO __str__ ... or maybe not?

class Message(models.Model):

    """ Everyone can communicate with someone else using private messages.

    These messages are recorded here. """

    timestamp = models.DateTimeField(auto_now_add=True)

    text = models.TextField(

        blank=False,

        )

    sender = models.ForeignKey(

        "Account",

        on_delete=models.CASCADE,

        null=False,

        #editable=False,

        help_text=_("The account that sent this message."),

        )

    # TODO __str__

class Chat(models.Model):

    """ Chats can happen between a group, or between two people in private.

    These messages are connected to a particular chat. """

    messages = models.ManyToManyField(

        "Message",

        help_text=_("All messages that were shared in this chat."),

        )

    shared_files = models.ManyToManyField(

        "SharedFile",

        help_text=_("The files that are shared in this chat."),

        )

    class Meta:

        abstract=True

class GroupChat(Chat):

    """ Represents a chat of a group. """

    group = models.ForeignKey(

        "Group",

        on_delete=models.CASCADE,

        null=False,

        #editable=False,

        )

    def __str__(self):

        return str(self.group)

class PrivateChat(Chat):

    """ Represents a private chat between two accounts. """

    # FIXME: It's theoretically possible to start a chat by one person, and have

    # the other person start the same as well. Find a reliable way to block that.

    account1 = models.ForeignKey(

        "Account",

        on_delete=models.CASCADE,

        null=False,

        #editable=False,

        )

    account2 = models.ForeignKey(

        "Account",

        on_delete=models.CASCADE,

        null=False,

        #editable=False,

        related_name="correspondent",

        )

    def __str__(self):

        return str(self.account1) +" - "+ str(self.account2)

class GroupInvite(models.Model):

    """ Groups can send invites to other people to join the group, and this is

    not limited to private groups. Group invitations are stored here, as well as their outcome. """

    inviter = models.ForeignKey(

        "Account",

        on_delete=models.CASCADE,

        null=False,

        #editable=False,

        )

    invitee = models.ForeignKey(

        "Account",

        on_delete=models.CASCADE,

        null=False,

        #editable=False,

        help_text=_("The account which will receive the invitation."),

        related_name="invitee",

        )

    group = models.ForeignKey(

        "Group",

        on_delete=models.CASCADE,

        null=False,

        #editable=False,

        db_index=True,

        help_text=_("The group for which this invitation is."),

        )

    accepted = models.NullBooleanField(

        default=None,

        help_text=_("Indicates if the invitation was accepted, rejected, or "

                    "pending an answer. if somebody rejects the invitation, "

                    "that group can no longer send an invitation to the invitee, "

                    "unless (s)he removes the answer from her history. Also, "

                    "a person can not reject an invitation, and accept it later. "

                    "For that, a new invitation must be received."),

        )

    def __str__(self):

        return str(self.invitee) +" | "+ str(self.group)