132 app/models/content.py
View file
@@ -6,27 +6,155 @@
from sqlalchemy.sql import functions

from app.models.base import Model
from app.models.user import User
from app.libs.db import db_session


class Topic(Model):
name = Column('name', String(30), index=True, unique=True, nullable=False)
name = Column('name', String(30), unique=True, nullable=False)
admin_id = Column('admin_id', Integer(), default=1)
avatar = Column('avatar', String(100), nullable=False)
description = Column('description', String(420), nullable=False)
rules = Column('rules', Text(), nullable=False)

@classmethod
def count(cls):
return cls.query.count()

@classmethod
def count_by_user(cls, username):
return cls.query.filter()

@classmethod
def create(cls, name, created_name, avatar, description, rules):
user = User.get_by_name(created_name)
t = Topic(name=name, admin_id=user.id, avatar=avatar,
description=description, rules=rules)
db_session.add(t)

def update(self, description=None, rules=None):
if description:
self.description = description
if rules:
self.rules = rules
db_session.add(self)

def created_user(self):
return User.get(self.created_id)

def administer(self):
return User.get(self.admin_id)


class Post(Model):
topic_id = Column('topic_id', Integer(), index=True, nullable=False)
author_id = Column('author_id', Integer(), index=True, nullable=False)
title = Column('title', Text(120), nullable=False)
date = Column('date', DateTime(timezone=True), default=functions.now())
created_date = Column('created_date', DateTime(timezone=True),
default=functions.now())
update_date = Column('update_date', DateTime(timezone=True),
default=functions.now(), onupdate=functions.now())
keywords = Column('keywords', String(120), nullable=False)
content = Column('content', Text(), default='')
keep_silent = Column('keep_silent', Boolean(), default=False)

@classmethod
def count(cls):
return cls.query.count()

@classmethod
def count_by_user(cls, username):
user = User.get_by_name(username)
return cls.query.filter(cls.author_id==user.id).count()

@classmethod
def count_by_topic(cls, topic_id):
return cls.query.filter(cls.topic_id==topic_id).count()

@classmethod
def get_by_user(cls, username):
user = User.get_by_name(username)
return cls.query.filter(cls.author_id==user.id).all()

@classmethod
def get_by_topic(cls, topic_id):
return cls.query.filter(cls.topic_id==topic_id).all()

@classmethod
def create(cls, author_name, topic_id, title, keywords,
content='', keep_silent=False):
p = cls(
topic_id=topic_id,
author_id=User.get_by_name(author_name).id,
title=title,
keywords=keywords,
content=content,
keep_silent=keep_silent,
)
db_session.add(p)

def update(self, keywords=None, content=None, keep_silent=None):
if keywords:
self.keywords = keywords
if content:
self.content = content
if keep_silent:
self.keep_silent = keep_silent
db_session.add(self)

def delete(self):
db_session.delete(self)

def author(self):
return User.get(self.author_id)

def topic(self):
return Topic.get(self.topic_id)


class Comment(Model):
post_id = Column('post_id', Integer(), index=True, nullable=False)
author_id = Column('author_id', Integer(), index=True, nullable=False)
date = Column('date', DateTime(timezone=True), default=functions.now())
content = Column('content', Text(), nullable=False)

@classmethod
def count(cls):
return cls.query.count()

@classmethod
def count_by_user(cls, username):
user = User.get_by_name(username)
return cls.query.filter(cls.author_id==user.id).count()

@classmethod
def count_by_post(cls, post_id):
return cls.query.filter(cls.post_id==post_id).count()

@classmethod
def get_by_user(cls, username):
user = User.get_by_name(username)
return cls.query.filter(cls.author_id==user.id).all()

@classmethod
def get_by_post(cls, post_id):
return cls.query.filter(cls.post_id==post_id).all()

@classmethod
def create(cls, author_name, post_id, content):
user = User.get_by_name(author_name)
c = cls(author_id=user.id, post_id=post_id, content=content)
db_session.add(c)

def update(self, content):
self.content = content
db_session.add(self)

def delete(self):
db_session.add(self)

def author(self):
return User.get(self.author_id)

def post(self):
return Post.get(self.post_id)
BIN +3.24 KB app/models/content.pyc
View file
Binary file not shown.
84 app/models/notification.py
View file
@@ -1,34 +1,106 @@
# -*- coding: utf-8 -*-

#TODO: get by unread, FUCK...

from __future__ import print_function, division, absolute_import

from sqlalchemy import Column, Integer, DateTime, String, Boolean
from sqlalchemy.sql import functions

from app.models.base import Model
from app.models.user import User
from app.libs.db import db_session


class Notification(Model):
sender = Column('sender', Integer(), index=True, nullable=False)
recipient = Column('recipient', Integer(), index=True, nullable=False)
sender_id = Column('sender_id', Integer(), index=True, nullable=False)
recipient_id = Column('recipient_id', Integer(), index=True, nullable=False)
activity_type = Column('activity_type', String(50), nullable=False)
content_url = Column('content_url', String(100), nullable=False)
unread = Column('unread', Boolean(), nullable=False)
date = Column('date', DateTime(timezone=True), default=functions.now())

@classmethod
def count_by_recipient(cls, username):
user = User.get_by_name(username)
return cls.query.filter(cls.recipient_id==user.id).count()

@classmethod
def count_by_type(cls, type_):
return cls.query.filter(cls.activity_type==type_).count()

@classmethod
def get_by_recipient(cls, username):
user = User.get_by_name(username)
return cls.query.filter(cls.recipient_id==user.id).all()

@classmethod
def get_by_activity_type(cls, type_):
return cls.query.filter(cls.activity_type==type_).all()

@classmethod
def create(cls, sender_name, recipient_name, activity_type, content_url):
sender = User.get_by_name(sender_name)
recipient = User.get_by_name(recipient_name)
n = cls(sender_id=sender.id, recipient_id=recipient.id,
activity_type=activity_type, content_url=content_url)
db_session.add(n)

def mark_as_read(self):
self.unread = True
db_session.add(self)

def sender(self):
return User.get(self.sender_id)

def recipient(self):
return User.get(self.recipient_id)


class Announcement(Model):
sender = Column('sender', Integer(), index=True, nullable=False)
recipient = Column('recipient', Integer(), index=True, nullable=False)
sender_id = Column('sender_id', Integer(), index=True, nullable=False)
recipient_id = Column('recipient_id', Integer(), index=True, nullable=False)
activity_type = Column('activity_type', String(50), nullable=False)
content_url = Column('content_url', String(100), nullable=False)
date = Column('date', DateTime(timezone=True), default=functions.now())
expire = Column('expire', DateTime(timezone=True), default=functions.now())

@classmethod
def get_by_recipient(cls, username):
user = User.get_by_name(username)
return cls.query.filter(cls.recipient_id==user.id).all()

@classmethod
def expired(cls, id_):
announcement = cls.get(id_)
return announcement.expire <= announcement.date

def sender(self):
return User.get(self.sender_id)

def recipient(self):
return User.get(self.recipient_id)


class PrivateMessage(Model):
sender = Column('sender', Integer(), index=True, nullable=False)
recipient = Column('recipient', Integer(), index=True, nullable=False)
sender_id = Column('sender_id', Integer(), index=True, nullable=False)
recipient_id = Column('recipient_id', Integer(), index=True, nullable=False)
message = Column('message', Integer(), nullable=False)
unread = Column('unread', Boolean(), nullable=False)
date = Column('date', DateTime(timezone=True), default=functions.now())

@classmethod
def get_by_sender(cls, username):
user = User.get_by_name(username)
return cls.query.filter(cls.sender_id==user.id).all()

@classmethod
def get_by_recipient(cls, username):
user = User.get_by_name(username)
return cls.query.filter(cls.recipient_id==user.id).all()

def sender(self):
return User.get(self.sender_id)

def recipient(self):
return User.get(self.recipient_id)
BIN +4.82 KB app/models/notification.pyc
View file
Binary file not shown.
6 app/models/permission.py
View file
@@ -4,6 +4,7 @@

from sqlalchemy import Column, Integer, String, event
from sqlalchemy.sql import select, functions
from sqlalchemy.orm import load_only

from app.models.base import Model

@@ -12,6 +13,11 @@ class Permission(Model):
bit = Column('number', Integer, index=True)
role = Column('role', String(24), index=True, nullable=False)

@classmethod
def get_by_role(cls, role):
r = cls.query.options(load_only('bit')).filter(cls.role==role)
return r.first()


@event.listens_for(Permission, 'before_insert')
def bit_generater(mapper, connection, target):
BIN +1.67 KB app/models/permission.pyc
View file
Binary file not shown.
119 app/models/user.py
View file
@@ -3,10 +3,12 @@
from __future__ import print_function, division, absolute_import

from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime
from sqlalchemy.orm import relationship
from sqlalchemy.orm import relationship, expression
from sqlalchemy.sql import functions

from app.models.base import Model
from app.models.permission import Permission
from app.libs.db import db_session


class User(Model):
@@ -17,10 +19,77 @@ class User(Model):
role = Column('role', Integer(), nullable=False)
profile = relationship('Profile', uselist=False, back_populates='user')

@classmethod
def get_by_name(cls, username):
return cls.query.filter(cls.username==username).first()

@classmethod
def get_by_email(cls, email):
return cls.query.filter(cls.email==email).first()

@classmethod
def create(cls, **kwargs):
user_attrs = dict()
profile_attrs = dict()
for k, v in kwargs.items():
if hasattr(cls, k):
user_attrs[k] = v
elif hasattr(Profile, k):
profile_attrs[k] = v
profile = Profile(**profile_attrs)
user_attrs.update({'profile': profile})
user = cls(**user_attrs)
db_session.add(user)
db_session.add(profile)

def delete(self):
db_session.delete(self.profile)
db_session.delete(self)

def update(self, **kwargs):
for k, v in kwargs.items():
if hasattr(self, k):
setattr(self, k, v)
elif hasattr(self.profile, k):
setattr(self.profile, k, v)
db_session.add(self)

def has_permission(self, role):
return self.query.filter(self.role&Permission.get_by_role(role))

def permissions(self):
r = self.query.join(Permission).filter(
self.role&Permission.bit).filter(self.__class__.id==self.id)
return r.all()

def information(self):
info = {
'id': self.id,
'username': self.username,
'role': self.permissions(),
'gold': self.profile.gold,
'intorduce': self.profile.join_date,
'avatar': self.profile.avatar,
'location': self.profile.avatar,
'wiki': self.profile.wiki,
'blog': self.profile.blog,
'github': self.profile.github,
'google': self.profile.google,
'weibo': self.profile.weibo,
'twitter': self.profile.twitter,
}
return info

def following_count(self):
return Following.get_count_by_userid(self.id)

def blocked_count(self):
return Blocked.get_count_by_userid(self.id)


class Profile(Model):
user_id = Column('user_id', Integer(), ForeignKey('user.id'))
gold = Column('gold', Integer(), index=True, nullable=False)
gold = Column('gold', Integer(), index=True, nullable=False, default=50)
join_date = Column('join_date', DateTime(timezone=True),
default=functions.now())
introduce = Column('introduce', Text(300), default='You know, 2L~')
@@ -38,7 +107,53 @@ class Following(Model):
user_id = Column('user_id', Integer(), index=True, nullable=False)
following_id = Column('following_id', Integer(), index=True, nullable=False)

@classmethod
def get_count_by_userid(cls, user_id):
return cls.query.filter(cls.user_id==user_id).count()

@classmethod
def list_following_id(cls, user_id):
return cls.query.filter(cls.user_id==user_id).all()

@classmethod
def create(cls, username, following_name):
user = User.get_by_name(username)
following = User.get_by_name(following_name)
f = Following(user_id=user.id, following_id=following.id)
db_session.add(f)

@classmethod
def get_by_user_following(cls, username, following_name):
user = User.get_by_name(username)
following = User.get_by_name(following_name)
r = cls.query.filter(expression.and_(cls.user_id==user.id,
cls.following_id==following.id))
return r.first()


class Blocked(Model):
user_id = Column('user_id', Integer(), index=True, nullable=False)
blocked_id = Column('blocked_id', Integer(), index=True, nullable=False)

@classmethod
def get_count_by_userid(cls, user_id):
return cls.query.filter(cls.user_id==user_id).count()

@classmethod
def list_blocked_id(cls, user_id):
return cls.query.filter(cls.user_id==user_id).all()

@classmethod
def create(cls, username, blocked_name):
user = User.get_by_name(username)
blocked = User.get_by_name(blocked_name)
f = Blocked(user_id=user.id, blocked_id=blocked.id)
db_session.add(f)

@classmethod
def get_by_user_blocked(cls, username, blocked_name):
user = User.get_by_name(username)
blocked = User.get_by_name(blocked_name)
r = cls.query.filter(expression.and_(cls.user_id==user.id,
cls.blocked_id==blocked.id))
return r.first()
BIN +6.5 KB app/models/user.pyc
View file
Binary file not shown.