from pfunk import (Collection, StringField, ReferenceField, DateField,
                   Project, Enum, EnumField, IntegerField, FloatField,
                  SlugField)
from pfunk.contrib.auth.collections import User, Group
from pfunk.contrib.auth.resources import GenericGroupBasedRole, GenericUserBasedRole



STATUS = Enum(name='ProductStatus', choices=['unstarted', 'started', 'completed', 'delivered'])


class AbstractGroupCollection(Collection):
    """
    Abstract Collection very similar to abstract models in Django. 
    The main difference is you don't have to add abstract=True in the Meta class.
    """
    # Here we are defining the roles that should be 
    # created for this collection (by proxy this role will be applied 
    # to its subclasses. We could however change the list of roles below.
    collection_roles = [GenericGroupBasedRole]
    title = StringField(required=True)
    group = ReferenceField(Group, required=True)

    def __unicode__(self):
        return self.title


class Product(AbstractGroupCollection):
    slug = SlugField(required=True)
    description = StringField()
    due_date = DateField(required=False)

    class Meta:
        """
        Add unique together index to ensure that the same slug is not used 
        for more than one product that belongs to a group. Similar to the
        Github's repo naming convention ex. https://github.com/capless/pfunk. 
        In that example 'capless' is the group slug and 'pfunk' is the 
        product's slug
        """
        unique_together = ('slug', 'group')


class Sprint(AbstractGroupCollection):
    product = ReferenceField(Product, required=True)
    start_date = DateField(required=True)
    end_date = DateField(required=True)


class Story(AbstractGroupCollection):
    description = StringField()
    points = IntegerField()
    product = ReferenceField(Product, required=True)
    sprint = ReferenceField(Sprint, required=False)
    status = EnumField(STATUS)


# Create a Project
project = Project()

# Add Collections to the Project
project.add_resources([User, Group, Product, Story, Sprint])

project.publish()

from pfunk.contrib.auth.collections import Group, User
group = Group.create(name='base', slug='base')

# Example 2: You could also create a user with the following code
user = User.create(username='notthegoat', first_name='Lebron', last_name='James',
                   email='notthegoat@gmail.com', account_status='ACTIVE', groups=[group],
                   _credentials='hewillneverbethegoat')

# User instance from above (username: notthegoat)
user.add_permissions(group, ['create', 'read', 'write', 'delete'])

from pfunk.contrib.auth.collections import User

#The login classmethod returns the authenticated token if the credentials are correct.
token = User.login('goat23', 'cruelpass')

# Use the token from above so the current users permissions are used.


product = Product.create(
    title='PFunk Project',
    slug='pfunk',
    description='Some example project for test Pfunk',
    group=group,
    _token=token #The token gained in the previous step. If you do not specify a token here it defaults to the key used in the FAUNA_SECRET env.
)

product = Product.get('the-key-for-the-previous-video', _token=token)

products = Products.all()

products = Products.all(_token=token)

product.delete()

pfunk init schoolzone

from pfunk.collection import Collection
from pfunk.fields import StringField, IntegerField, ReferenceField, ManyToManyField
from pfunk.contrib.auth.collections import User, Group
from pfunk.contrib.auth.resources import GenericGroupBasedRole


class School(Collection):
    collection_roles = [GenericGroupBasedRole]
    name = StringField(required=True)
    address = StringField(required=False)
    group = ReferenceField(Group, required=True)


class Teacher(Collection):
    collection_roles = [GenericGroupBasedRole]
    first_name = StringField(required=True)
    last_name = StringField(required=True)
    group = ReferenceField(Group, required=True)


class Class(Collection):
    collection_roles = [GenericGroupBasedRole]
    name = StringField(required=True)
    teacher = ReferenceField(Teacher)
    group = ReferenceField(Group, required=True)


class Student(Collection):
    collection_roles = [GenericGroupBasedRole]
    first_name = StringField(required=True)
    last_name = StringField(required=True)
    grade = IntegerField(required=True)
    group = ReferenceField(Group, required=True)


class StudentClass(Collection):
    collection_roles = [GenericGroupBasedRole]
    class_ref = ReferenceField(Class)
    student_ref = ReferenceField(Student)
    final_grade = IntegerField(required=False)
    absences = IntegerField()
    tardies = IntegerField()
    group = ReferenceField(Group, required=True)

from pfunk import Project
from pfunk.contrib.auth.collections import Key
from .collections import School, Teacher, Class, Student, StudentClass, User, Group


project = Project(_collections=[User, Group, School, Teacher, Class, Student, StudentClass])