class Role(db.Model):
uuid = db.Attribute(indexed=False)
name = db.Attribute(required=True)
description = db.Attribute(indexed=False)
created_at = db.DateTimeField()
updated_at = db.DateTimeField()
permission = db.IntegerField(required=True)
def __repr__(self):
return "<{}-{:04X}>".format(self.name, self.permission)
def __str__(self):
return self.__repr__()
def __unicode__(self):
return self.__repr__()
def to_json(self, user):
rst = self.attributes_dict
rst["created_at"] = format_datetime(self.created_at)
rst["updated_at"] = format_datetime(self.updated_at)
rst["created_by"] = user.id
rst["updated_by"] = user.id
rst["id"] = self.id
return rst
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 CommentModel(models.Model):
author = models.Attribute()
message = models.Attribute()
contentId=models.Attribute()
commentId=models.Attribute()
commentTo=models.Attribute()
gmtCreate = models.DateTimeField(auto_now_add=True)
class Link(r_models.Model):
"""Model that represents a shortened URL."""
short_url = r_models.Attribute(unique=True)
url = r_models.Attribute(required=True)
date_submitted = r_models.DateTimeField(auto_now_add=True)
usage_count = r_models.IntegerField(default=0, indexed=True)
is_custom = r_models.BooleanField()
def __unicode__(self):
return '%s : %s' % (self.url, self.short_url)
def save(self, *args, **kwargs):
if hasattr(self, 'id'):
super(self.__class__, self).save(*args, **kwargs)
return
if self.is_custom:
pass
else:
self.short_url = utils.get_short_url()
while True:
existing_link = self.__class__.objects.filter(
short_url=self.short_url)
if existing_link:
if self.is_custom:
raise ValueError('Custom url already exists')
else:
self.short_url = utils.get_short
else:
break
super(self.__class__, self).save(*args, **kwargs)
class Upload(db.Model):
post = db.IntegerField(required=True)
filename = db.Attribute(required=True)
local_path = db.Attribute(required=True)
cloud = db.IntegerField(required=True)
url = db.Attribute(required=True)
done_at = db.DateTimeField(auto_now_add=True)
class DeskModel(models.Model):
desk_id = models.Attribute(unique=True)
desk_owner = models.Attribute()
desk_points = models.Counter()
def add_id(self):
self.desk_id = str(1000+int(self.id))
self.save()
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 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 PlayerModel(models.Model):
playerId = models.Attribute()
player_phone = models.Attribute(required=True)
player_name = models.Attribute(required=True)
player_password = models.Attribute()
last_login = models.DateTimeField()
player_points = models.Counter()
player_vip = models.IntegerField(default=0)
player_desk = models.Attribute()
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 UserInterface(models.Model):
''''''
id = models.IntegerField(required=True, unique=True)
user = models.Attribute(required=True, unique=True)
pwd = models.Attribute()
description = models.Attribute()
email = models.Attribute()
avatar = models.Attribute()
last_login = models.DateTimeField(auto_now=True)
class EventsDetails(models.Model):
"""
Count against protocols
"""
request_id = models.Attribute(required=True, unique=True)
template_id = models.Attribute(required=True)
status = models.Attribute(required=True)
@property
def db(cls):
return redis.Redis(connection_pool=connection_pool)
class AccessToken(models.Model):
"""
Model to store, in redis (via redisco) all tokens and their status
"""
uid = models.Attribute(required=True, indexed=True, unique=True)
login = models.Attribute(required=True, indexed=True)
token = models.Attribute(required=True, indexed=True)
backend = models.Attribute(required=True, indexed=True)
status = models.IntegerField(required=True, indexed=True, default=200)
last_use = models.DateTimeField(auto_now_add=True, auto_now=True)
last_message = models.Attribute()
def __unicode__(self):
return str(self)
def __str__(self):
return self.uid
def save(self):
is_new = self.is_new()
result = super(AccessToken, self).save()
if result == True and is_new:
self.release()
return result
def is_valid(self):
"""
Overrive the default method to save the uid, which is unique (by
concatenating backend and token)
"""
self.uid = '%s:%s:%s' % (self.backend, self.login, self.token)
return super(AccessToken, self).is_valid()
def lock(self):
"""
Set the token as currently used
"""
return connection.srem(AVAILABLE_LIST_KEY, self.uid)
def release(self):
"""
Set the token as not currently used
"""
return connection.sadd(AVAILABLE_LIST_KEY, self.uid)
def set_status(self, code, message):
"""
Set a new status and message for this token
"""
self.status = code
self.last_message = message
self.save()
class UserModel(models.Model):
gmtCreate = models.Attribute()
openid = models.Attribute()
nickName= models.Attribute()
avatarUrl= models.Attribute()
province= models.Attribute()
city= models.Attribute()
gender= models.Attribute()
country= models.Attribute()
language= models.Attribute()
tel=models.Attribute()
class Images(db.Model):
post_id = db.IntegerField(required=True)
status = db.Attribute(required=True, default="active")
image_name = db.Attribute(indexed=False)
height = db.IntegerField(indexed=False)
width = db.IntegerField(indexed=False)
url = db.Attribute(indexed=False)
delete_url = db.Attribute()
local_path = db.Attribute(indexed=False)
def to_json(self):
return {
"id": self.id, "post_id": self.post_id,
"image_name": self.image_name,
"url": self.url, "local_path": self.local_path
}
class Trade(models.Model):
exec_id = models.Attribute(required=True)
order = models.ReferenceField('Order')
trade_time = models.DateTimeField(required=True)
price = models.FloatField(required=True, indexed=False)
volume = models.FloatField(required=True, indexed=False)
closed_volume = models.FloatField(required=True,
default=0.0,
indexed=False)
commission = models.FloatField(required=True, default=0.0, indexed=False)
profit = models.FloatField(required=True, default=0.0, indexed=False)
@property
def opened_volume(self):
return self.volume - self.closed_volume
@property
def amount(self):
return self.order.instrument.amount(self.price, self.volume)
@property
def opened_amount(self):
return self.order.instrument.amount(self.price, self.opened_volume)
def on_trade(self, price, volume, trade_time, exec_id, is_open):
self.price = float(price)
self.volume = float(volume)
self.trade_time = trade_time
self.exec_id = exec_id
self.commission = self.order.instrument.calc_commission(
price, volume, is_open)
assert self.is_valid(), self.errors
self.save()
def on_close(self):
for orig_trade in self.order.orig_order.trades:
if abs(self.closed_volume) >= abs(self.volume):
break
if orig_trade.opened_volume == 0.0:
continue
if abs(orig_trade.opened_volume) < abs(self.opened_volume):
vol = orig_trade.opened_volume
else:
vol = -self.opened_volume
logger.debug('Trade {0} against {1} close volume={2}'.format(
self.exec_id, orig_trade.exec_id, vol))
self.closed_volume -= vol
orig_trade.closed_volume += vol
if self.order.instrument.indirect_quotation:
self.profit += self.order.instrument.amount(
orig_trade.price, vol) - self.order.instrument.amount(
self.price, vol)
else:
self.profit += self.order.instrument.amount(
self.price - orig_trade.price, vol)
assert orig_trade.is_valid(), orig_trade.errors
orig_trade.save()
assert self.is_valid(), self.errors
self.save()
class PlayerDeskGame(models.Model):
desk = models.Attribute()
player = models.ReferenceField(PlayerModel)
game = models.ReferenceField(GameModel)
player_bet = models.ReferenceField(BetModel)
player_win = models.IntegerField()
player_remind = models.IntegerField()
is_banker = models.BooleanField(default=False)
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 HttpRecord(BaseModel):
uidentify = models.Attribute(required=True, indexed=True)
name = models.Attribute(required=True)
method = models.Attribute(required=True)
data = models.Attribute()
user_agent = models.Attribute()
content_type = models.Attribute()
remote_addr = models.Attribute()
class Stock(models.Model):
sc_code = models.IntegerField(required=True)
sc_name = models.Attribute(required=True)
created_at = models.DateTimeField(auto_now_add=True)
sc_open = models.FloatField()
sc_high = models.FloatField()
sc_low = models.FloatField()
sc_close = models.FloatField()
sc_prevclose = models.FloatField()
sc_volume = models.IntegerField()
class Comment(db.Model):
# 评论者的用户名
author_name = db.Attribute()
# 评论者的邮箱，如果没有设置头像会根据这个信息从gravatar获取头像
author_email = db.Attribute()
# 评论者的URL，评论者头像或者名字会跳转到改URL
author_url = db.Attribute()
# 评论者的IP
ip = db.Attribute()
# 评论者User Agent信息，通常包括浏览器版本、引擎、设备等信息
agent = db.Attribute()
# 这条评论被【赞】的次数，该属性导入意义不大，会在被喜欢之后重新统计
likes = db.IntegerField()
# 对这条评论点了【举报】的次数
reports = db.IntegerField()
# 评论发表时间。
created_at = db.DateTimeField()
# 评论状态。
status = db.IntegerField()
class DeviceInterface(models.Model):
''''''
dev_id = models.Attribute(required=True, unique=True)
ip = models.Attribute(required=True)
type = models.Attribute(required=True)
name = models.Attribute(required=True)
status = models.Attribute(required=True)
static_info = models.Attribute(required=False)
service_status = models.Attribute(required=False)
class Category(db.Model):
name = db.Attribute(required=True)
super = db.IntegerField()
def to_json(self):
jsn = {
"id": self.id,
"name": self.name
}
if self.super:
jsn['super'] = self.super
return jsn
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 Chairman(models.Model):
id = models.Attribute(unique=True)
# pk = models.Attribute(unique=True)
title = models.Attribute()
name = models.Attribute()
href = models.Attribute()
img = models.Attribute()
num = models.IntegerField()
desc = models.Attribute()
type = models.Attribute()
avatar = models.Attribute()
object_name = 'chairman'
def __init__(self, *args, **kwargs):
super(Chairman, self).__init__(**kwargs)
if 'ele' in kwargs:
ele = json.loads(kwargs['ele'])
self.id = ele['_id']
self.title = ele['_title']
self.name = ele['_name']
self.href = ele['_href']
self.num = ele['_num']
self.img = ele['_img']
self.desc = ele['_desc']
self.type = ele['_type']
self.avatar = ele['_avatar']
def set_id(self, id):
self.pk = id
self.id = id
def set_num(self, num):
if '万' in num:
self.num = int(
round(
float(
num.replace('万', '').replace('\r', '').replace(
'\n', '')) * 10000))
else:
self.num = int(num)
def __unicode__(self):
return json.dumps(self,
default=lambda o: o.__dict__,
sort_keys=True,
indent=4)
class Product(models.Model):
"""
>>> p = Product.objects.create(prodid='XX', exchangeid='XXXX')
>>> p
XX
>>> p.instruments
[]
>>> i = Instrument.objects.create(secid='XX1505', name='XX1505', symbol='XX1505', product=p, quoted_currency='USD')
>>> p.instruments
[XX1505]
>>> i.delete()
>>> p.delete()
"""
prodid = models.Attribute()
exchangeid = models.Attribute()
is_trading = models.BooleanField()
main_inst = models.ReferenceField(Instrument)
def __repr__(self):
return self.prodid
@property
def instruments(self):
return Instrument.objects.filter(product_id=self.id)
class LinkAccess(r_models.Model):
"""Model that represents access of a shortened url."""
link = r_models.ReferenceField(Link)
country = r_models.Attribute()
region = r_models.Attribute()
referrer = r_models.Attribute()
lat = r_models.Attribute()
lng = r_models.Attribute()
ip = r_models.Attribute()
atime = r_models.DateTimeField(auto_now_add=True)
def save(self, *args, **kwargs):
super(LinkAccess, self).save(*args, **kwargs)
thread.start_new_thread(geotag_link_access, (self, True))
class Tag(db.Model):
uuid = db.Attribute(indexed=False)
name = db.Attribute(indexed=False)
slug = db.Attribute(indexed=False)
hidden = db.BooleanField()
parent = db.Attribute(indexed=False)
image = db.Attribute(indexed=False)
meta_title = db.Attribute(indexed=False)
meta_description = db.Attribute(indexed=False)
created_at = db.DateTimeField()
updated_at = db.DateTimeField()
def to_json(self):
rst = self.attributes_dict
rst["id"] = self.id
rst["created_at"] = format_now_datetime(self.created_at)
rst["updated_at"] = format_now_datetime(self.updated_at)
rst["created_by"] = None
rst["updated_by"] = None
return rst
class Person(models.Model):
name = models.Attribute()
friend = models.ReferenceField('Person')
