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 Exam(models.Model): score = models.IntegerField() total_score = models.IntegerField() def percent(self): return int((float(self.score) / self.total_score) * 100) class Meta: indices = ('percent', )
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 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 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 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 LogEntry(rmodels.Model): num = rmodels.IntegerField() time = rmodels.FloatField() date = rmodels.DateTimeField(auto_now_add=True) class Meta: verbose_name = 'Search index update statistic' verbose_name_plural = 'Search index update statistic' db = default_connection
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 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 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 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 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 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 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 Character(models.Model): n = models.IntegerField() m = models.CharField() word = models.ReferenceField(Word)
class Tweet(models.Model): status_id = models.IntegerField()
class Person(models.Model): age = models.IntegerField()
class Ninja(models.Model): age = models.IntegerField(required=True) def validate(self): if self.age >= 10: self._errors.append(('age', 'must be below 10'))
class Ninja(models.Model): def validator(field_name, age): if not age or age >= 10: return ((field_name, 'must be below 10'), ) age = models.IntegerField(required=True, validator=validator)
class Character(models.Model): n = models.IntegerField() m = models.CharField()
class Order(models.Model): OS_NONE, OS_NEW, OS_CANCELED, OS_FILLED, OS_CLOSING, OS_CLOSED, OS_REJECTED = range( 7) account = models.ReferenceField('Account') local_id = models.Attribute() sys_id = models.Attribute(default='') strategy_code = models.Attribute(default='') instrument = models.ReferenceField(Instrument) is_long = models.BooleanField(indexed=False) is_open = models.BooleanField(indexed=True) order_time = models.DateTimeField() price = models.FloatField(indexed=False) volume = models.FloatField(indexed=False) status = models.IntegerField(default=OS_NONE) orig_order = models.ReferenceField('Order', related_name='close_orders') stop_profit_offset = models.FloatField(indexed=False, default=0.0) # 止赢偏离值 stoploss = models.FloatField(indexed=False, default=0.0) # 止损价 stopprofit = models.FloatField(indexed=False, default=0.0) # 止赢价 def __repr__(self): return u'<Order: {0.id}({0.instrument}:{0.opened_volume})>'.format( self) def is_closed(self): return self.status == Order.OS_CLOSED @property def currency(self): return self.instrument.quoted_currency @property def can_close(self): return self.status == Order.OS_FILLED @property def can_cancel(self): if self.status in (Order.OS_NONE, Order.OS_NEW): return True elif self.status == Order.OS_FILLED: if abs(self.filled_volume) < abs(self.volume): return True return False @property def trades(self): return Trade.objects.filter(order_id=self.id).order('trade_time') @property def filled_volume(self): return sum([trade.volume for trade in self.trades]) @property def closed_volume(self): return sum([trade.closed_volume for trade in self.trades]) @property def opened_volume(self): """ 剩余开仓量 """ return sum([trade.opened_volume for trade in self.trades]) @property def opened_amount(self): return sum([trade.opened_amount for trade in self.trades]) @property def commission(self): return sum([trade.commission for trade in self.trades]) @property def real_profit(self): return sum([trade.profit for trade in self.trades]) @property def trade_amt(self): return sum([trade.amount for trade in self.trades]) @property def avg_fill_price(self): if self.filled_volume: if self.instrument.indirect_quotation: return self.filled_volume * self.instrument.multiplier / self.trade_amt else: return self.trade_amt / (self.filled_volume * self.instrument.multiplier) return None @property def cur_price(self): return current_price(self.instrument.secid, self.opened_volume > 0) @property def strategy(self): return STRATEGIES.get(self.strategy_code) def delete(self, *args, **kwargs): for t in self.trades: t.delete() super(Order, self).delete(*args, **kwargs) def update_index_value(self, att, value): assert att in ('status', 'is_open', 'local_id', 'sys_id') pipeline = self.db.pipeline() # remove from old index indkey = self._index_key_for_attr_val(att, getattr(self, att)) pipeline.srem(indkey, self.id) pipeline.srem(self.key()['_indices'], indkey) # add to new index # in version 0.1.4 there is a bug in self._add_to_index(att, value, pipeline): # the val paramter doesnot work, it's ignored. # so i have to hardcode it as following t, index = self._index_key_for(att, value) if t == 'attribute': pipeline.sadd(index, self.id) pipeline.sadd(self.key()['_indices'], index) elif t == 'list': for i in index: pipeline.sadd(i, self.id) pipeline.sadd(self.key()['_indices'], i) elif t == 'sortedset': zindex, index = index pipeline.sadd(index, self.id) pipeline.sadd(self.key()['_indices'], index) descriptor = self.attributes[att] score = descriptor.typecast_for_storage(value) pipeline.zadd(zindex, self.id, score) pipeline.sadd(self.key()['_zindices'], zindex) # set db value pipeline.hset(self.key(), att, value) pipeline.execute() # set instance value setattr(self, att, value) def update_status(self, value): value = int(value) assert 0 <= value < 7 logger.debug('update order {2} status from {0} to {1}'.format( getattr(self, 'status'), value, self.sys_id)) self.update_index_value('status', value) def change_to_open_order(self): self.update_index_value('is_open', 1) def update_local_id(self, value): value = str(value) self.update_index_value('local_id', value) def update_sys_id(self, value): value = str(value) self.update_index_value('sys_id', value) def update_float_value(self, att, value): assert att in ('stoploss', 'stopprofit', 'stop_profit_offset', 'volume') value = float(value) self.db.hset(self.key(), att, value) setattr(self, att, value) def update_stopprice(self, stoploss=None, stopprofit=None): if stoploss is not None: self.update_float_value('stoploss', stoploss) if stopprofit is not None: self.update_float_value('stopprofit', stopprofit) def update_stop_profit_offset(self, value): self.update_float_value('stop_profit_offset', value) def margin(self, cur_price=None): cur_price = cur_price or self.cur_price return self.instrument.calc_margin(cur_price, self.opened_volume) def float_profit(self, cur_price=None): cur_price = cur_price or self.cur_price profit = self.instrument.amount( cur_price, self.opened_volume) - self.opened_amount if self.instrument.indirect_quotation: profit *= -1 return profit def on_new(self, orderid, instid, direction, price, volume, exectime): instrument = Instrument.objects.filter(secid=instid).first() #assert self.is_open is not None self.sys_id = orderid self.instrument = instrument self.is_long = direction self.price = float(price) self.volume = float(volume) self.order_time = exectime self.status = Order.OS_NEW assert self.is_valid(), self.errors self.save() def on_trade(self, price, volume, tradetime, execid): assert self.is_open is not None # check duplicate trade if Trade.objects.filter(exec_id=execid): logger.debug(u'EXECID {0} 已经存在!'.format(execid)) return False if not self.is_long: volume = -volume t = Trade(order=self) t.on_trade(price, volume, tradetime, execid, self.is_open) self.update_status(Order.OS_FILLED) logger.info(u'<策略{0}>成交回报: {1}{2}仓 合约={3} 价格={4} 数量={5}'.format( self.strategy_code, u'开' if self.is_open else u'平', u'多' if self.is_long == self.is_open else u'空', self.instrument.name, price, volume, )) return t def set_stopprice(self, price, offset_loss=0.0, offset_profit=0.0): # 静态止赢价 if offset_profit and not self.stopprofit: if self.is_long: stopprofit = price + offset_profit else: stopprofit = price - offset_profit self.update_stopprice(stopprofit=stopprofit) logger.debug('Order {0} set stop profit price to {1}'.format( self.sys_id, self.stopprofit)) # 浮动止损价 if offset_loss: if self.is_long: stoploss = price - offset_loss if self.stoploss and stoploss <= self.stoploss: return else: stoploss = price + offset_loss if self.stoploss and stoploss >= self.stoploss: return self.update_stopprice(stoploss) logger.debug('Order {0} set stop loss price to {1}'.format( self.sys_id, self.stoploss)) def on_close(self, trade): trade.on_close() if abs(self.orig_order.closed_volume) >= abs( self.orig_order.filled_volume): self.orig_order.update_status(Order.OS_CLOSED) logger.debug(u'订单{0}已全部平仓'.format(self.orig_order.sys_id)) if (abs(self.closed_volume) >= abs(self.volume)) or (abs( self.closed_volume) >= abs(self.orig_order.filled_volume)): self.update_status(Order.OS_CLOSED) logger.debug(u'订单{0}已全部平仓'.format(self.sys_id))
class CardModel(models.Model): card_suit = models.Attribute() card_rank = models.IntegerField()
class User(models.Model): views = models.IntegerField(default=199) liked = models.BooleanField(default=True) disliked = models.BooleanField(default=False)
class Instrument(models.Model): """ >>> i = Instrument(secid='XX1505', name='XX 2015/05', symbol='XX-1505', quoted_currency='USD', multiplier=10.0) >>> print i XX-1505 """ secid = models.Attribute(required=True) name = models.Attribute(required=True) symbol = models.Attribute(required=True) exchangeid = models.Attribute() product = models.ReferenceField('Product') quoted_currency = models.Attribute(required=True, indexed=False) indirect_quotation = models.BooleanField(indexed=False) ndigits = models.IntegerField(indexed=False, default=2) multiplier = models.FloatField(indexed=False) open_commission_rate = models.FloatField(indexed=False, default=0) close_commission_rate = models.FloatField(indexed=False, default=0) tick_size = models.FloatField(indexed=False) tick_value = models.FloatField(indexed=False) min_order_volume = models.FloatField(indexed=False, default=1.0) max_order_volume = models.FloatField(indexed=False, default=99999999.0) effective_date = models.DateField(indexed=False) expire_date = models.DateField(indexed=False) is_trading = models.BooleanField() long_margin_ratio = models.FloatField(indexed=False) short_margin_ratio = models.FloatField(indexed=False) volume = models.FloatField(indexed=False) def __repr__(self): return self.symbol def amount(self, price, volume): if not price: return 0.0 if self.indirect_quotation: return volume * self.multiplier / price else: return volume * self.multiplier * price def calc_margin(self, price, volume, direction=None): if direction: return abs(self.amount(price, volume) * self.long_margin_ratio) else: return abs(self.amount(price, volume) * self.short_margin_ratio) def amount2volume(self, amt, price): if not price: return 0.0 if self.indirect_quotation: return amt * price / self.multiplier else: return amt / price / self.multiplier def margin2volume(self, margin, price, direction=None): if direction: amt = margin / self.long_margin_ratio else: amt = margin / self.short_margin_ratio return self.amount2volume(amt, price) def calc_commission(self, price, volume, is_open): if is_open: if self.open_commission_rate is None: self.open_commission_rate = 0.000025 commission = abs(self.amount(price, volume)) * self.open_commission_rate else: if self.close_commission_rate is None: self.close_commission_rate = 0.000025 commission = abs(self.amount(price, volume)) * self.close_commission_rate ndigits = self.ndigits or 2 return round(commission, ndigits) @classmethod def symbol2id(cls, symbol): instance = cls.objects.filter(symbol=symbol).first() if instance: return instance.secid @classmethod def from_id(cls, secid): return cls.objects.filter(secid=secid).first() @classmethod def all_ids(cls): return [obj.secid for obj in cls.objects.all()] def deadline(self): if self.exchangeid in ('DCE', 'CZCE'): # 大连/郑州 d = self.expire_date.replace(day=1) - datetime.date.resolution while d.weekday() >= 5: # weekend d = d - datetime.date.resolution t = datetime.time(14, 0) elif self.exchangeid == 'SHFE': # 上期 d = self.expire_date - datetime.timedelta(3) t = datetime.time(14, 0) elif self.exchangeid == 'CFFEX': # 中金所 d = self.expire_date t = datetime.time(14, 55) else: d = self.expire_date t = datetime.time(23, 59) return datetime.datetime.combine(d, t)
class BetModel(models.Model): bank = models.IntegerField() player = models.IntegerField() tie = models.IntegerField() bankPair = models.IntegerField() playerPair = models.IntegerField()
class AdminModel(models.Model): admin_name = models.Attribute(required=True, unique=True) admin_password = models.Attribute() admin_grade = models.IntegerField()
class HandSelModel(models.Model): sender = models.Attribute() receiver = models.Attribute() points = models.IntegerField() date = models.DateTimeField(auto_now_add=True) success = models.BooleanField(default=False)
class Comment(models.Model): comment_id = models.IntegerField(indexed=True) created_at = models.DateTimeField(auto_now_add=True, indexed=True) comment = models.Attribute(required=True, indexed=True) user = models.ReferenceField(User, indexed=True)
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() last_message = models.Attribute() suspended_until = models.DateTimeField() def __unicode__(self): return str(self) def __str__(self): return self.uid def save(self): is_new = self.is_new() self.last_use = datetime.utcnow() result = super(AccessToken, self).save() if result is True and is_new: self.release() return result def is_valid(self): """ Override 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() def suspend(self, suspended_until=None, message=None): """ Suspend the token until the given utc timestamp """ if suspended_until: self.suspended_until = datetime.utcfromtimestamp(suspended_until) else: self.suspended_until = None self.last_message = message self.save() if suspended_until: # We make the `suspended_until` key auto expire key = self.key('suspended_until') connection.expire(key, round(suspended_until - now_timestamp()) + 1)
class Cloud(db.Model): name = db.IntegerField(required=True) upload_url = db.IntegerField(required=True) app_key = db.Attribute(required=False) app_secret = db.Attribute(required=False) extras = db.Attribute(indexed=False)