class GroupSettings(RBase):
id = models.Attribute(required=True)
welcome_text = models.Attribute(default='')
invite_text = models.Attribute(default='')
group_tmpl = models.Attribute(default='')
creators = models.ListField(str, default=[])
creator_names = models.ListField(str, default=[])
class GameModel(models.Model):
desk = models.Attribute()
game_time = models.DateTimeField(auto_now_add=True)
all_bet = models.IntegerField(default=0)
all_paid = models.IntegerField(default=0)
game_result = models.ListField(int)
bank_cards = models.ListField(int)
player_cards = models.ListField(int)
class DeviceInfoInterface(models.Model):
''''''
timestamp = models.DateTimeField(required=True)
cpu_usage = models.Attribute()
mem_usage = models.Attribute()
net_usage = models.Attribute()
net_flow = models.ListField(dict)
proc_info = models.ListField(dict)
class DomainInfo(re_models.Model):
name = re_models.Attribute(required=True)
created_at = re_models.DateTimeField(auto_now_add=True)
res_code = re_models.IntegerField(default=0)
alert = re_models.BooleanField(default=False)
new_msg = re_models.BooleanField(default=True)
address = re_models.ListField(str)
no_ip = re_models.ListField(str)
info = re_models.Attribute()
class TestSuit_Maintaince(models.Model):
''''''
id = models.Counter(required=True, unique=True)
overview = models.Attribute(required=True)
target = models.Attribute(required=True)
status = models.Attribute(required=True)
detail = models.ListField(dict)
class ContentModel(models.Model):
contentId=models.Attribute()
gmtCreate = models.DateTimeField(auto_now_add=True)
author = UserModel
section=models.Attribute()
content = models.Attribute()
title=models.Attribute()
imgList=models.ListField(str)
class User(models.Model):
name = models.CharField()
likes = models.ListField('Link')
def likes_link(self, link):
if self.likes is None:
self.likes = [link]
self.save()
else:
if link not in self.likes:
self.likes.append(link)
self.save()
class User(db.Model):
uuid = db.Attribute(indexed=False)
name = db.Attribute(required=True)
slug = db.Attribute(indexed=False)
email = db.Attribute(required=True)
avatar = db.Attribute(required=True,
indexed=False,
default=DEFAULT_AVATAR_URL)
password = db.Attribute(required=True, indexed=False)
image = db.Attribute(indexed=False)
cover = db.Attribute(indexed=False)
bio = db.Attribute(indexed=False)
website = db.Attribute(indexed=False)
facebook = db.Attribute(indexed=False)
twitter = db.Attribute(indexed=False)
accessibility = db.BooleanField(indexed=False)
status = db.Attribute()
language = db.Attribute(indexed=False)
visibility = db.BooleanField()
meta_title = db.Attribute(indexed=False)
meta_description = db.Attribute(indexed=False)
tour = db.Attribute(indexed=False)
last_login = db.DateTimeField()
created_at = db.DateTimeField()
updated_at = db.DateTimeField()
role = db.ListField(Role, required=True)
def to_json(self):
rst = self.attributes_dict
del rst['password']
del rst['role']
rst['id'] = self.id
rst['last_login'] = format_datetime(self.last_login)
rst['created_at'] = format_datetime(self.created_at)
rst['updated_at'] = format_datetime(self.updated_at)
rst['roles'] = [role.to_json(self) for role in self.role]
return rst
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return str(self.id)
class User(models.Model):
username = models.Attribute(required=True, unique=True, label='Username')
password = models.Attribute(required=True, label='Password')
email = models.Attribute(required=True, unique=True, label='Email')
name = models.Attribute(required=True, label='Name')
groups = models.ListField(Group, label='Groups')
def __init__(self, *args, **kwargs):
super(User, self).__init__(*args, **kwargs)
self.job = ['one', 'two', 'three']
def save(self):
if self.is_new():
self.attributes['password'] = hashlib.md5(self.password)
else:
if self.password:
self.attributes['password'] = hashlib.md5(self.password)
return super(User, self).save()
def validate_password(self, password):
return self.password == hashlib.md5(password).hexdigest()
@property
def permissions(self):
perms = []
for group in self.groups:
perms += group.permissions
return perms
@property
def link(self):
from solder import url
return link_to(self.username, url.current(controller='user',\
action='show', id=self.username))
@staticmethod
def get(username):
return User.objects.filter(username=username).first()
class CardList(models.Model):
identifier = models.Attribute()
text = models.Attribute()
cards = models.ListField(Card)
class Author(models.Model):
name = models.CharField(required=True)
books = models.ListField(Book)
class Cake(models.Model):
name = models.CharField()
ingredients = models.ListField(str)
sizes = models.ListField(int)
class Group(models.Model):
name = models.Attribute(required=True, unique=True, label='Name')
label = models.Attribute(required=True, unique=True, label='Name')
permissions = models.ListField(Permission, label='Permissions')
class DeviceDynamicInterface(models.Model):
''''''
dev_id = models.Attribute(required=True)
timestamp = models.DateTimeField(required=True)
dynamic_info = models.ListField(DeviceInfoInterface, required=False)
class User(orm.RediscoModle):
'''
要存库的数据类型
'''
# uid = models.IntegerField(required=True, unique=True)
username = models.Attribute(required=True,
unique=True,
validator=validateAccount)
password = models.Attribute(required=True, validator=validatePassword)
''' 注册时间 '''
register_time = models.DateTimeField(auto_now_add=True)
''' 最后登录时间 '''
last_login_time = models.DateTimeField(auto_now=True)
''' 所属的用户组 '''
_userGroups = models.ListField(target_type=str)
''' 是否注销 '''
is_cancel = models.BooleanField(default=True)
''' root用户的账号和密码 '''
rootAccount = 'root'
import p
rootPassword = p.pw
def validate(self):
'''
:return:
'''
errss = ''
for errs in self._errors:
err = " ".join(errs)
print err
errss += err
if self._errors:
print 'are the reasons to '
return errss
# @classmethod
# def obj(cls, ):
# '''
# 根据用户名获取玩家
# :param args: [username]
# :return:
# '''
# username = args[0]
# return cls.objects.filter(username=username).first()
@classmethod
def all(cls):
'''
获得所有用户的实例
:return:
'''
return cls.objects.filter().all().exclude(username=cls.rootAccount)
@classmethod
def createNewUser(cls, username, password):
'''
创建新的用户
:param username:
:param password:
:return:
'''
# TODO 密码明文加密, 暂时不做加密，直接保存明文
# user = User(uid=userUid, username=username, password=password)
user = User(username=username, password=password)
''' 检查账号是否生成成功 '''
if not user.is_valid():
''' 生成失败，直接报错退出 '''
raise ValueError(user.errStr)
# if NEW_ACCOUNT_ERR_NOT_UNIQUE in user.validate():
# raise ValueError('用户名重复!!!')
''' 生成新的用户的id '''
counter = Counter.obj()
counter.incr(Counter.user)
user.id = counter.uid
''' 生成成功，账号存库 '''
user.save()
return user
@property
def userGroups(self):
'''
根据 userGroup.id索引回用户组实例
:return:
'''
ugs = []
for ugid in [ugid for ugid in self._userGroups]:
ug = UserGroup.obj(id=ugid)
''' 如果该id已经作废，则移除 '''
self._userGroups.remove(ugid) if ug is None else ugs.append(ug)
return ugs
@property
def lastLoginTime(self):
'''
最后登录时间
:return:
'''
return self.last_login_time
@property
def registerTime(self):
'''
注册时间
:return:
'''
return self.register_time
@property
def isCancel(self):
'''
真个账号是否已经注销
:return:
'''
return self.is_cancel
def addUserGroup(self, userGroup):
'''
加入指定的用户组
:param userGroup:
:return:
'''
if not isinstance(userGroup, UserGroup):
errInfo = '分配用户组失败!!!\nclass:%s不是指定的用户组类型%s!!!' % type(
userGroup), UserGroup.__name__
raise TypeError(errInfo)
if userGroup in self.userGroups:
errInfo = '用户已经在用户组 uid:%d %s 中了' % (userGroup.id, userGroup.name)
raise ValueError(errInfo)
self._userGroups.append(userGroup.id)
self.save()
def removeUserGroup(self, userGroup):
'''
移除用户组
:param ug:
:return:
'''
if not isinstance(userGroup, UserGroup):
errInfo = '分配用户组失败!!!\nclass:%s不是指定的用户组类型%s!!!' % type(
userGroup), UserGroup.__name__
raise TypeError(errInfo)
if userGroup not in self.userGroups:
errInfo = '用户不在用户组 id:%d %s 中了' % (userGroup.id, userGroup.name)
raise ValueError(errInfo)
self._userGroups.remove(userGroup.id)
@classmethod
def createRoot(cls):
'''
生成root用户
:return:
'''
''' 生成root用户实例 '''
root = User.createNewUser(User.rootAccount, User.rootPassword)
root.initRootUg()
root.save()
return root
def initRootUg(self):
'''
初始化root用户的root用户组权限
:return:
'''
if self.username != self.__class__.rootAccount:
raise ValueError('该用户不是root用户!!!')
''' 检查用户组 '''
rootUg = UserGroup.obj(name=UserGroup.rootGroup)
if rootUg:
''' 如果用户组存在，删除掉 '''
rootUg.delete(User)
rootUg = UserGroup.createRootGroup()
rootUg.save()
''' 清空root的用户组 '''
while len(self.userGroups) > 0:
self._userGroups.pop(0)
''' 添加root用户组 '''
self._userGroups.append(rootUg.id)
def getPms(self):
'''
从所有用户组获得权限
:return:
'''
p = set()
for userGroup in self.userGroups:
p |= userGroup.pms
return p
def isHavePms(self, permissions):
'''
用户是否拥有某几种权限
:param permission: 只能传递 UserGroup.PERMISSION_*进来
:return:
'''
return permissions & self.getPms()
def isInUg(self, ug):
'''
是否在这个用户组中
:param ug: UserGroup()
:return:
'''
if not isinstance(ug, UserGroup):
raise ValueError('错误的用户组类型: %s' % ug.__class__.__name__)
return ug in self.userGroups
def getUserGroupByName(self, name):
'''
根据 userGroup.name 获得 UserGroup()
:param name:
:return: UserGroup() or None
'''
for ug in self.userGroups:
if ug.name == name:
return ug
return None
def isPW(self, pw):
return self.password == pw
def getUGNames(self):
'''
获得所有组名的数组
:return:
'''
ns = []
for ug in self.userGroups:
ns.append(ug.name)
return ns
def getUnjoinGroups(self):
'''
获得未加入的用户组
:return:
'''
ugs = UserGroup.all()
unj = []
j = self.getUGNames()
for ug in ugs:
if ug.name not in j:
unj.append(ug)
return unj
class RoomModel(models.Model):
roomId=models.Attribute()
gmtCreate = models.DateTimeField(auto_now_add=True)
users = models.ListField(str)
class UserGroup(orm.RediscoModle, PM):
'''
要存库的数据类型
'''
''' 超级用户组 '''
rootGroup = 'root'
# uid = models.IntegerField(required=True, unique=True)
name = models.Attribute(required=True, unique=True)
# permissions = models.IntegerField(default=0)
permissions = models.ListField(str)
# users = models.ListField(target_type=baseuser.User)
@classmethod
def all(cls):
'''
获取所有用户组
:return:
'''
return cls.objects.filter().all().exclude(name=cls.rootGroup)
@property
def pms(self):
"""
权限是以英文字符来表示
:return: set([str, ...])
"""
return set(self.permissions)
@classmethod
def getAllPms(cls):
'''
获得全权限
:return:
'''
allPms = set()
for pm in cls.getPermissionDic().values():
allPms |= pm
return allPms
def getPmsName(self):
'''
获得所持有的权限名
:return:
'''
pmsName = []
for pmn, pm in self.getPermissionDic().items():
if self.isHavePms(pm):
pmsName.append(pmn)
return pmsName
def validate(self):
'''
:return:
'''
errss = ''
for errs in self._errors:
err = " ".join(errs)
print err
errss += err
if self._errors:
print 'are the reasons to '
return errss
@classmethod
def createNewUserGroup(cls, name, permissions=None):
'''
创建新的用户组
:return:
'''
userGroup = UserGroup(name=name)
''' 配置用户组权限 '''
if permissions is None:
userGroup.permissions = PM.defaultPms()
else:
userGroup.setPms(permissions)
if not userGroup.is_valid():
raise ValueError(userGroup.errors)
''' 设置用户组id和用户组名 '''
counter = Counter.obj()
counter.incr(Counter.userGroup)
userGroup.id = counter.ugid
''' 存库 '''
userGroup.save()
return userGroup
def addPms(self, pms):
'''
给用户组添加权限
:param permission: 必须以 UserGroup.PERMISSION_* 来传递
:return:
'''
self.permissions = list(self.pms | pms)
def setPms(self, pms):
'''
直接将用户组的权限置为指定的权限
:param permissions:
:return:
'''
self.permissions = list(pms)
def removePms(self, pms):
'''
给用户组减少权限
:param permission:
:return:
'''
# if permissions not in self.__class__.getPermissionDic().values():
# effInfo = '用户组: %s设定权限失败!!非法的权限 %d !!!' % (self.name, permissions)
# raise ValueError(effInfo)
''' 先授权，在卸权。因为计算算法的原因，所以这么做 '''
self.addPms(pms)
self.permissions -= pms
self.save()
def isHavePms(self, permissions):
'''
该用户组是否有某种权限
:param permission:
:return: bool
'''
return permissions & self.pms
@classmethod
def createRootGroup(cls):
'''
生成root用户组
:return:
'''
''' root 用户组拥有全部权限 '''
pms = cls.getAllPms() - cls.PERMISSION_BAN_LOGIN
ug = UserGroup.createNewUserGroup(UserGroup.rootGroup, pms)
return ug
@classmethod
def getPmNames(cls):
'''
所有权限的名字数组
:return:
'''
names = []
for n in cls.getPermissionDic().keys():
ls = n.split('_')
n = '_'.join(ls[0:])
names.append(n)
return names
def removeAllPms(self):
'''
移除 该用户组 所有权限
:return:
'''
self.removePms(self.pms)
def delete(self, User):
'''
重写 delete 方法，删除用户组需要同时将从用户身上删除用户组
:return:
'''
for u in User.all():
if self in u.userGroups:
u.removeUserGroup(self)
u.save()
''' 从redis中删除实例 '''
orm.RediscoModle.delete(self)
class Post(db.Model):
title = db.Attribute(required=True)
slug = db.Attribute(required=True)
markdown = db.Attribute(indexed=False)
content = db.Attribute(indexed=False)
image = db.Attribute(indexed=False)
featured = db.BooleanField()
page = db.BooleanField()
status = db.Attribute(required=True)
language = db.Attribute(indexed=False)
meta_title = db.Attribute(indexed=False)
meta_description = db.Attribute(indexed=False)
updated_at = db.DateTimeField(auto_now=True)
updated_by = db.ReferenceField(User)
published_at = db.DateTimeField()
created_at = db.DateTimeField()
created_by = db.ReferenceField(User)
author = db.ReferenceField(User)
publishedBy = db.ReferenceField(User)
categories = db.ListField(Category)
tags = db.ListField(Tag)
# 相对于站点目录的路径，全小写
path = db.Attribute(required=False, indexed=False)
# 文档的完整路径, 全小写
full_path = db.Attribute(required=False, indexed=False)
# 文档的完整路径, 保留大小写
raw_path = db.Attribute(required=False, indexed=False)
# path的父目录路径
parent_path = db.Attribute(required=False, indexed=False)
# full_path的父目录路径
parent_full_path = db.Attribute(required=False, indexed=False)
# raw_path的父目录路径
parent_raw_path = db.Attribute(required=False, indexed=False)
# 文档类型，有folder/post/image/file四种
type = db.Attribute(required=False, indexed=False)
# 文档的时间，比如可作为文章的发表时间
date = db.DateTimeField(auto_now=True)
# 文档最后修改时间，评论文章也会导致m_date变动
m_date = db.Attribute(required=False, indexed=False)
# 文档的最后修改时间
raw_date = db.Attribute(required=False, indexed=False)
# 用户自定义的位置, 浮点数类型
position = db.Attribute(required=False, indexed=False)
# 文档的大小
size = db.Attribute(required=False, indexed=False)
# 内容类型，比如image/jpeg
content_type = db.Attribute(required=False, indexed=False)
visits = db.Attribute(required=False, indexed=False)
# 在不改变文件路径的前提下，约等于访问IP数
_visits = db.Attribute(required=False, indexed=False)
# 文件后缀名，比如jpg txt
ext = db.Attribute(required=False, indexed=False)
# TableOfContens, HTML格式
toc = db.Attribute(required=False, indexed=False)
# 文章封面, 从内容中提取出来的第一张图片
cover = db.Attribute(required=False, indexed=False)
# 纯文本格式的正文，不包含metadata
raw_content = db.Attribute(required=False, indexed=False)
# 原始正文，包含metadata信息
_content = db.Attribute(required=False, indexed=False)
# post的扩展属性
metadata = db.Attribute(required=False, indexed=False)
# 自定义的url
url_path = db.Attribute(required=False, indexed=False)
# '/post/’+url_path 或 /+url_path，视情况而定
url = db.Attribute(required=False, indexed=False)
# 评论数
comments_count = db.Attribute(required=False, indexed=False)
# 恒等于1
posts_count = db.Attribute(required=False, indexed=False)
def __repr__(self):
return "<Post: {post.id} Title: {post.title}>".format(post=self)
def to_json(self):
rtn = self.attributes_dict
rtn["id"] = self.id
rtn["date"] = format_now_datetime(self.published_at)
rtn["updated_at"] = format_now_datetime(self.updated_at)
rtn["updated_by"] = self.updated_by.id if self.updated_by else None
rtn["published_at"] = format_now_datetime(self.published_at)
rtn["created_at"] = format_now_datetime(self.created_at)
rtn["created_by"] = self.created_by.id if self.created_by else None
rtn["publishedBy"] = self.publishedBy.id if self.publishedBy else None
rtn["categories"] = [cate.to_json() for cate in self.categories]
rtn["tags"] = [tag.to_json() for tag in self.tags]
rtn["author"] = self.author.to_json()
return rtn
class Account(models.Model):
code = models.Attribute(required=True)
default_currency = models.Attribute(required=True,
indexed=False,
default='USD')
last_trade_time = models.DateTimeField(indexed=False)
balances = models.ListField(Balance, indexed=False)
def __init__(self, *args, **kwargs):
super(Account, self).__init__(*args, **kwargs)
self.real_profits = 0.0
@property
def orders(self):
return Order.objects.filter(account_id=self.id)
def opened_orders(self, instrument=None, strategy_code=''):
key = 'opened_orders:{0}:{1}:{2}'.format(self.id, instrument,
strategy_code)
cached = self.db.get(key)
if cached:
return [Order.objects.get_by_id(oid) for oid in json.loads(cached)]
else:
queryset = self.orders
if instrument:
queryset = queryset.filter(instrument_id=instrument.id)
if strategy_code:
queryset = queryset.filter(strategy_code=strategy_code)
orders = list(queryset.filter(status=Order.OS_FILLED))
orders.extend(list(queryset.filter(status=Order.OS_CLOSING)))
cached = json.dumps([o.id for o in orders])
self.db.setex(key, cached, 1)
return orders
def untraded_orders(self, instrument=None, strategy_code=''):
queryset = self.orders
if instrument:
queryset = queryset.filter(instrument_id=instrument.id)
if strategy_code:
queryset = queryset.filter(strategy_code=strategy_code)
orders = list(queryset.filter(status=Order.OS_NEW))
queryset = queryset.filter(status=Order.OS_FILLED)
orders.extend(
[o for o in queryset if abs(o.filled_volume) < abs(o.volume)])
return orders
def combined_positions(self):
qs = sorted(self.opened_orders(), key=attrgetter('instrument_id'))
groups = groupby(qs, attrgetter('instrument'))
for inst, orders in groups:
yield inst, sum([o.opened_volume for o in orders])
@property
def balance(self):
return sum(
[b.convert_to(self.default_currency) for b in self.balances])
@property
def available(self):
if getattr(self, '_available', None) is None:
return self.balance - self.margins + self.float_profits
return self._available
@property
def margins(self):
return sum([
convert_currency(o.margin(), o.currency, self.default_currency)
for o in self.opened_orders()
])
@property
def float_profits(self):
return sum([
convert_currency(o.float_profit(), o.currency,
self.default_currency)
for o in self.opened_orders()
])
def open_orders(self, strategy_code=''):
queryset = self.orders.filter(is_open=True)
if strategy_code:
queryset = queryset.filter(strategy_code=strategy_code)
return queryset
def balance_in(self, ccy):
return self.get_balance_object(ccy).value
def get_balance_object(self, currency):
try:
balance = [b for b in self.balances if b.currency == currency][0]
except IndexError:
balance = Balance(currency=currency, value=0.0)
balance.save()
self.balances.append(balance)
self.save()
return balance
def book(self, change, currency, memo):
balance = self.get_balance_object(currency)
balance.value += float(change)
assert balance.is_valid(), balance.errors
balance.save()
msg = u'{3}：{0}{1}, 余额{2}{1}'.format(change, currency, balance.value,
memo)
if u'利润' in msg:
logger.info(msg)
else:
logger.debug(msg)
def deposit(self, quantity, currency=''):
currency = currency or self.default_currency
self.book(quantity, currency, u'转入资金')
def set_balance(self, quantity, currency=''):
currency = currency or self.default_currency
balance = self.get_balance_object(currency)
balance.value = float(quantity)
assert balance.is_valid(), balance.errors
balance.save()
logger.debug(u'设置资金余额：{0}{1}'.format(quantity, currency))
def set_available(self, available):
self._available = available
def create_order(self,
local_order_id,
inst=None,
price=None,
volume=None,
is_open=None,
strategy_code='',
orig_order=None):
assert is_open is None or is_open == (orig_order is None), (is_open,
orig_order)
neworder = Order.objects.filter(local_id=local_order_id).first()
if not neworder:
neworder = Order(local_id=local_order_id, instrument=inst)
try:
neworder.price = float(price)
except:
pass
try:
neworder.volume = float(volume)
except:
pass
logger.debug('NEWORDER local_id={0}'.format(neworder.local_id))
neworder.update_attributes(account=self,
is_open=is_open,
strategy_code=strategy_code)
if orig_order:
neworder.orig_order = orig_order
if not neworder.strategy_code:
neworder.strategy_code = orig_order.strategy_code
assert neworder.is_valid(), neworder.errors
neworder.save()
return neworder
def on_trade(self, order, execid, price, volume, tradetime):
trade = order.on_trade(price, volume, tradetime, execid)
if not trade:
return
self.book(-trade.commission, order.currency,
u'<策略{0}>收取手续费'.format(order.strategy_code))
if not order.is_open:
# 平仓
order.on_close(trade)
self.book(trade.profit, order.currency,
u'<策略{0}>获取利润'.format(order.strategy_code))
self.real_profits += trade.profit
if not self.last_trade_time or self.last_trade_time < tradetime:
self.last_trade_time = tradetime
self.save()
