path: root/grumpy/models.py

# -*- coding: utf-8 -*-
"""
    grumpy.models
    ~~~~~~~~~~~~~

    This module contains the models and low-level database glue for the
    application.

    :copyright: (c) by 2010 Priit Laes.
    :license: BSD, see LICENSE for details.
"""
from . import app
from datetime import datetime
from flaskext.sqlalchemy import SQLAlchemy
from sqlalchemy.sql import func

import json, random, string

db = SQLAlchemy(app)

# Association tables
package_developers = db.Table('package_developers', db.Model.metadata,
    db.Column('package_id', db.Integer, db.ForeignKey('packages.id')),
    db.Column('developer_id', db.Integer, db.ForeignKey('developers.id'))
    )
package_herds = db.Table('package_herds', db.Model.metadata,
    db.Column('package_id', db.Integer, db.ForeignKey('packages.id')),
    db.Column('herd_id', db.Integer, db.ForeignKey('herds.id'))
    )

class Category(db.Model):
    """Represents portage categories"""

    __tablename__ = 'categories'
    id = db.Column('id', db.Integer, primary_key=True)
    cat = db.Column('category', db.String, nullable=False, unique=True)

    def __init__(self, cat):
        self.cat = cat

    def __repr__(self):
        return '<%s> "%s"' % (self.__class__.__name__, self.cat)

class Developer(db.Model):
    """Represents developers in the system"""

    __tablename__ = 'developers'
    id = db.Column('id', db.Integer, primary_key=True)
    email = db.Column('email', db.String, nullable=False, unique=True)

    def __init__(self, email):
        self.email = email

class Ebuild(db.Model):
    """Represents single ebuilds (cpv) in the system"""

    __tablename__ = 'ebuilds'

    id = db.Column('id', db.Integer, primary_key=True)
    cpv = db.Column('cpv', db.String, nullable=False, unique=True)
    eapi = db.Column('eapi', db.Integer, nullable=False)
    # Regular USE flags
    iuse = db.Column('iuse', db.String)
    # Forced USE flags (+use)
    fiuse = db.Column('fiuse', db.String)
    keywords = db.Column('keywords', db.String)
    slot = db.Column('slot', db.String)
    version = db.Column('version', db.String, nullable=False)
    _package = db.Column('package_id', db.Integer, db.ForeignKey('packages.id'))
    # TODO: depend, rdepend, licenses
    # TODO: extra info?

    package = db.relationship("Package")

    def __init__(self, package, version, eapi, slot, keywords, \
                 iuse, fiuse):
        self.package = package
        self.version = version
        self.cpv = "%s/%s-%s" % (package.pkg, package.cat, self.version)
        self.eapi = eapi
        self.slot = slot
        self.iuse = ','.join(iuse)
        self.fiuse = ','.join(fiuse)
        self.keywords = ','.join(keywords)

    def __repr__(self):
        return '<%s> - %s' % (self.__class__.__name__, self.cpv)

class Favorite(db.Model):
    """Represents packages that user can add in their watch list."""

    __tablename__ = 'favorites'

    id = db.Column('id', db.Integer, primary_key=True)
    _package = db.Column('package_id', db.Integer, db.ForeignKey('packages.id'))
    _user = db.Column('user_id', db.Integer, db.ForeignKey('users.id'))

    package = db.relationship("Package")
    user = db.relationship("User", backref=db.backref('favorites'))

    def __init__(self, package):
        self.package = package

    def __repr__(self):
        return '<%s> - %s' % (self.__class__.__name__, self.package.cp)

class Setting(db.Model):
    """Housekeeping table for storing various system settings and info."""

    __tablename__ = 'settings'

    name = db.Column('name', db.String, primary_key=True, unique=True)
    rawdata = db.Column('data', db.Text)

    def __init__(self, name, data):
        self.name = name
        self.rawdata = json.dumps(data)

    @property
    def data(self):
        return json.loads(self.rawdata)

    def __repr__(self):
        return '<%s> - %s' % (self.__class__.__name__, self.name)


class Herd(db.Model):
    """Represents herds in the system"""

    __tablename__ = 'herds'

    id = db.Column('id', db.Integer, primary_key=True)
    name = db.Column('name', db.String, nullable=False, unique=True)
    # TODO: Do we really need to store other information about herds here?

    def __init__(self, name):
        self.name = name

class Package(db.Model):
    """Represents packages in the system"""

    __tablename__ = 'packages'

    id = db.Column('id', db.Integer, primary_key=True)
    cat = db.Column('cat', db.String, nullable=False)
    pkg = db.Column('pkg', db.String, nullable=False)
    cp = db.Column('cp', db.String, nullable=False, unique=True)
    desc = db.Column('desc', db.String)
    ldesc = db.Column('ldesc', db.String)
    homepage = db.Column('homepage', db.String)
    mtime = db.Column('mtime', db.DateTime)

    ebuilds = db.relationship(Ebuild, backref='ebuilds', \
                                   cascade='all, delete-orphan')
    qaissues = db.relationship("PkgIssue", backref='qa_issues', \
                                   cascade='all, delete-orphan')
    devs = db.relationship(Developer, secondary=package_developers, \
                                      backref='packages')
    herds = db.relationship(Herd, secondary=package_herds, backref='packages')

    def __init__(self, cat, pkg, desc, ldesc, homepage, mtime):
        self.cat = cat
        self.pkg = pkg
        self.cp = "%s/%s" % (pkg, cat)
        self.desc = desc
        self.ldesc = ldesc
        self.homepage = homepage
        self.mtime = datetime.fromtimestamp(mtime)
        self.devs = []
        self.herds = []
        self.ebuilds = []

    def __repr__(self):
        return '<%s> - %s' % (self.__class__.__name__, self.cp)

    def rename(self, newcat, newpkg):
        """Rename package and its ebuilds"""
        cp = "%s/%s" % (newpkg, newcat)
        self.cat = newcat
        self.pkg = newpkg
        self.cp = cp
        for ebuild in self.ebuilds:
            ebuild.cpv = "%s-%s" % (cp, ebuild.version)

class PkgIssue(db.Model):
    """Package-related issues"""

    __tablename__ = 'pkg_issues'

    id = db.Column('id', db.Integer, primary_key=True)
    plugin = db.Column('plugin', db.String)
    type = db.Column('type', db.String)
    data = db.Column('data', db.String)
    created_on = db.Column('created_on', db.DateTime, default=func.now())
    _package = db.Column('package_id', db.Integer, db.ForeignKey('packages.id'))

    package = db.relationship(Package)

    def __init__(self, package, plugin, type, data=None):
        self.package = package
        self.plugin = plugin
        self.data = data
        self.type = type

    def __repr__(self):
        return '<%s> - %s : %s' % \
            (self.__class__.__name__, self.plugin, self.type)

class User(db.Model):
    """User model"""
    __tablename__ = 'users'

    id = db.Column('id', db.Integer, primary_key=True)
    openid = db.Column('openid', db.String)
    email = db.Column('user', db.String, unique=True)
    apitoken = db.Column('apitoken', db.String)
    regtoken = db.Column('regtoken', db.String)
    created_on = db.Column('created_on', db.DateTime, default=func.now())

    def __init__(self, email, openid):
        self.email = email
        self.openid = openid
        # API token
        self.apitoken = None
        # Registration token
        self.regtoken = self.generate_token(8)

    def generate_token(self, length):
        return ''.join([random.choice(string.ascii_letters + \
                                      string.digits) for x in xrange(length)])