class EntrySpec(db.Document):
meta = {
'db_alias': 'cart_db',
'indexes': ['sku', 'item_id', ]
}
sku = db.IntField(required=True, unique=True)
item_id = db.IntField()
title = db.StringField()
primary_image = db.StringField()
item_available = db.BooleanField()
price = db.FloatField()
available = db.BooleanField()
attributes = db.DictField()
images = db.ListField(db.StringField())
attribute_list = db.ListField(db.StringField())
attribute_desc = db.DictField()
brand = db.DictField()
last_update_date = db.DateTimeField()
carts = db.ListField(db.ReferenceField('Cart'))
last_empty_date = db.DateTimeField()
class Item(db.Document):
content = db.StringField(required=True)
created_date = db.DateTimeField()
completed = db.BooleanField(default=False)
completed_date = db.DateTimeField()
created_by = db.ReferenceField('User', required=True)
notes = db.ListField(db.StringField())
priority = db.IntField()
def __repr__(self):
return "<Item: {} Content: {}>".format(str(self.id), self.content)
def to_json(self):
return {
'id':
str(self.id),
'content':
self.content,
'completed':
self.completed,
'completed_at':
self.completed_date.strftime("%Y-%m-%d %H:%M:%S")
if self.completed else "",
'created_by':
self.created_by.name,
'notes':
self.notes,
'priority':
self.priority
}
class UserAccount(db.EmbeddedDocument):
'''
The UserAccount class contains user personal informations
and account settings
'''
created_at = db.DateTimeField(default=datetime.datetime.utcnow,
required=True)
# login related
email = db.EmailField(required=True, unique=True)
mobile_number = db.StringField()
is_email_verified = db.BooleanField(default=False)
_password = db.StringField(max_length=255)
activation_key = db.StringField(max_length=255)
activate_key_expire_date = db.DateTimeField()
# ===============================================
# password
@property
def password(self):
return self._password
@password.setter
def password(self, password):
self._password = bcrypt.generate_password_hash(password).decode(
'utf-8')
print(self._password)
def check_password(self, password):
if self.password is None:
return False
return bcrypt.check_password_hash(self.password, password)
def to_json(self):
return dict(created_at=str(self.created_at), email=self.email)
class Todo(db.Document):
desc = db.StringField()
create_at = db.DateTimeField(default=datetime.now())
finished_at = db.DateTimeField(default=None) # todo的完成时间
is_finished = db.BooleanField(default=False) # todo状态:1. finished, 2. open
creator = db.ReferenceField('User')
todolist = db.ReferenceField('TodoList')
@property
def id(self):
return str(self._id)
@property
def status(self):
return 'finished' if self.is_finished else 'open'
def finished(self):
self.finished_at = datetime.now()
self.is_finished = True
self.save()
def reopen(self):
self.finished_at = None
self.is_finished = False
self.save()
def to_dict(self):
return {
'description': self.desc,
'creator': self.creator.username,
'create_at': self.create_at,
'finished_at': self.finished_at,
'status': self.status
}
class Coupon(db.Document):
meta = {
'strict': False,
'db_alias': 'order_db',
'indexes': ['code', 'apply', 'expire_date', 'description']
}
scope = db.StringField(required=True, choices=COUPON_SCOPE,
default=COUPON_SCOPE.ORDER)
coupon_type = db.StringField(default=COUPON_TYPES.NORMAL, required=True,
choices=COUPON_TYPES)
value = db.FloatField()
description = db.StringField()
effective_date = db.DateTimeField(default=datetime.utcnow)
expire_date = db.DateTimeField(default=datetime(2019, 12, 31))
code = db.StringField(unique=True)
# by which means this coupon can be applied: by coupon code, by display_id
apply = db.StringField(required=True, default=COUPON_APPLY.BY_DISPLAY_ID,
choices=COUPON_APPLY)
required_amount = db.FloatField(default=0)
required_final = db.FloatField(default=0)
require_new_order = db.BooleanField(default=False)
once_per_user = db.BooleanField(default=False)
# note for internal usage
note = db.StringField()
coupon_category = db.StringField(choices=['PROMOTION', 'STAFF',
'NEW_USER'], default='PROMOTION')
@property
def is_expired(self):
if not self.expire_date:
return False
return (datetime.utcnow() >= self.expire_date)
def to_json(self):
return dict(
coupon_type=self.coupon_type,
value=self.value,
code=self.code,
effective_date=format_date(self.effective_date, '%Y-%m-%d'),
expire_date=format_date(self.expire_date, '%Y-%m-%d'),
is_expired=self.is_expired,
description=self.description)
def is_effective(self):
return self.effective_date <= datetime.utcnow() < self.expire_date
def can_apply(self, order):
res = bool(
(self.required_final <= order.final) and
(self.required_amount <= order.amount) and
not (self.require_new_order and order.customer.orders) and
not (self.once_per_user and order.customer.used_coupon(self.code))
)
return res
class BaseEntry(db.Document):
meta = {'allow_inheritance': True}
spec = db.ReferenceField('ItemSpec')
item = db.ReferenceField('Item')
amount_usd = db.FloatField(default=0)
amount = db.FloatField(default=0) #CNY
quantity = db.IntField(default=1, required=True)
unit_price = db.FloatField(default=0)
# after discount
discount = db.ListField(db.DictField())
modified = db.DateTimeField()
created_at = db.DateTimeField(default=datetime.utcnow)
@property
def is_available(self):
return (self.spec.availability and self.item.availability)
def __unicode__(self):
return '%s' % self.id
def __repr__(self):
# __repr__ method can be used by flask-cache
return '{}({}:{})'.format(self.__class__.__name__,
self.item_spec_snapshot.sku, self.quantity)
def update_amount(self):
from application.models import ForexRate
self.unit_price = self.item_spec_snapshot.price
unit_price_cny = self.unit_price * ForexRate.get()
self.amount_usd = self.unit_price * self.quantity
self.amount = unit_price_cny * self.quantity
self.save()
def to_json(self, snapshot=False):
item = self.item_snapshot
spec = self.item_spec_snapshot
item_json = item.to_simple_json()
return dict(id=str(self.id),
item=item_json,
spec=spec.to_json(),
unit_price=self.unit_price,
amount=self.amount,
quantity=self.quantity,
weight=item.weight)
def clean(self):
if self.spec and not self.item:
self.item = self.spec.item
class PostLike(db.Document):
meta = {
'db_alias': 'content_db',
'indexes': ['user_id', 'post', 'created_at'],
'ordering': ['-created_at']
}
user_id = db.ObjectIdField()
post = db.ReferenceField('Post')
created_at = db.DateTimeField(default=datetime.utcnow, required=True)
@property
def user(self):
from application import models as Models
return Models.User.objects(id=self.user_id).first()
def to_json(self):
user = self.user
return dict(
id=str(self.id),
user=dict(id=str(user.id),
name=user.name,
avatar_url=user.avatar_url,
avatar_thumb=user.avatar_thumb),
)
class Address(db.Document):
created_at = db.DateTimeField(default=datetime.utcnow)
# address detail
country = db.StringField(required=True)
state = db.StringField(required=True)
city = db.StringField()
street1 = db.StringField()
street2 = db.StringField()
postcode = db.StringField()
# receiver infomation
receiver = db.StringField(required=True)
mobile_number = db.StringField()
def __unicode__(self):
return '%s' % str(self.id)
@property
def fields(self):
return [
'country', 'state', 'city', 'street1', 'street2', 'postcode',
'receiver', 'mobile_number'
]
def to_json(self):
result = {f: getattr(self, f) for f in self.fields}
result.update({'id': str(self.id)})
return result
class TodoList(db.Document):
title = db.StringField()
created_at = db.DateTimeField(default=datetime.now())
creator = db.ReferenceField('User')
todos = db.ListField(default=[])
@property
def id(self):
return str(self._id)
@property
def todo_count(self):
return len(self.todos)
@property
def finished_count(self):
return len(list(filter(lambda x: x.is_finished, self.todos)))
@property
def open_count(self):
return len(list(filter(lambda x: not x.is_finished, self.todos)))
def to_dict(self):
return {
'title': self.title,
'create_at': self.created_at,
'creator': self.creator.username,
'todo_count': self.todo_count,
'finished_count': self.finished_count,
'open_count': self.open_count
}
class ItemSpec(db.Document):
meta = {
'db_alias':
'inventory_db',
'indexes': [
'item_id', 'web_sku', 'sku', 'price', 'original_price',
'availability', 'attributes', 'created_at', 'stock'
],
'ordering': ['price']
}
item_id = db.IntField(required=True)
sku = db.SequenceField(required=True, unique=True, primary_key=True)
web_sku = db.StringField(required=True)
images = db.ListField(db.StringField(required=True))
original_price = db.FloatField(required=True, min_value=0)
price = db.FloatField(required=True, min_value=0)
china_price = db.FloatField(min_value=0, default=0)
availability = db.BooleanField(default=True, required=True)
stock = db.IntField(default=-1)
# spec.attributes: {color: 'Blue', size: 'M'}
attributes = db.DictField()
shipping_info = db.DictField()
created_at = db.DateTimeField(default=datetime.utcnow, required=True)
modified = db.DateTimeField()
url = db.StringField()
extra = db.DictField(default={})
@property
def item(self):
return Item.objects(item_id=self.item_id).first()
def __unicode__(self):
return '%s' % self.sku
def update_spec(self, new_spec):
for k, v in new_spec.items():
setattr(self, k, v)
self.save()
class ChangeLog(db.EmbeddedDocument):
'''
log all user actions of change for a board
'''
user = db.StringField()
date = db.DateTimeField(required=True, default=datetime.utcnow)
action = db.StringField()
item = db.StringField()
info = db.StringField()
class CoinWallet(db.Document):
meta = {'indexes': ['user']}
user = db.ReferenceField('User', unique=True)
balance = db.IntField(required=True, default=0)
holdding = db.IntField(required=True, default=0)
cash = db.IntField(required=True, default=0)
holdding_cash = db.IntField(required=True, default=0)
latest_expired_time = db.DateTimeField(default=datetime(
1989, 6, 4)) # latest expired_time of holdding trades
@classmethod
def create(cls, user, balance=0, holdding=0):
wallet = cls.objects(user=user).modify(upsert=True,
new=True,
set__user=user,
set__balance=balance,
set__holdding=holdding)
return wallet
@classmethod
def get_or_create(cls, user):
wallet = CoinWallet.objects(user=user).first()
if not wallet:
wallet = CoinWallet.create(user=user)
return wallet
def pay(self, order, amount, coin_type=COIN_TYPE.COIN):
if (coin_type == COIN_TYPE.COIN and amount > self.balance):
current_app.logger.error(
'Order coin exceed wallet balance. order: {}, amount: {}, balance: {}.'
.format(order.id, amount, self.balance))
amount = self.balance
if (coin_type == COIN_TYPE.CASH and amount > self.cash):
current_app.logger.error(
'Order cash exceed wallet balance. order: {}, amount: {}, balance: {}.'
.format(order.id, amount, self.cash))
amount = self.cash
from application import models as Models
time = datetime.utcnow()
reason = COIN_TRADE_REASON.PAY
kind = COIN_TRADE_TYPE.OUTCOME
user = Models.User.objects(id=order.customer_id).first()
trade = CoinTrade.create(user=user,
amount=amount,
time=time,
kind=kind,
reason=reason,
wallet=self,
reason_id=str(order.id),
coin_type=coin_type)
return trade
class LogisticIrregular(db.EmbeddedDocument):
steps = db.DictField()
process_status = db.StringField(
choices=['WAITING_PROCESS', 'PROCESSING', 'PROCESSED'],
default='WAITING_PROCESS')
irr_at_status = db.StringField(choices=LOG_STATS)
irr_type = db.StringField(default=u'OTHER')
reason = db.StringField()
desc = db.StringField()
creator = db.StringField()
created_at = db.DateTimeField(default=datetime.datetime.utcnow)
remarks = db.EmbeddedDocumentListField('LogisticRemark')
class ItemSnapshot(db.DynamicDocument):
meta = {
'db_alias': 'order_db',
'indexes': ['item_id', 'web_id', 'head']
}
head = db.IntField(required=True, default=0)
specs = db.ListField(db.ReferenceField('ItemSpecSnapshot'))
created_at = db.DateTimeField(default=datetime.datetime.utcnow())
def __unicode__(self):
return '%s' % self.head
@classmethod
def create(cls, item):
data = item._data
shot = cls(**data)
shot.head = shot.item_id
shot.save()
return shot
@property
def small_thumbnail(self):
return self.primary_img[:23] + 'thumbnails/150x150/' + self.primary_img[23:]
@property
def large_thumbnail(self):
return self.primary_img[:23] + 'thumbnails/400x400/' + self.primary_img[23:]
def update_to_head(self):
from application.models import Item
head = Item.objects(item_id=self.head).first()
if head:
data = head._data
for k, v in data.items():
setattr(self, k, v)
self.save()
else:
return self
@property
def is_changed(self):
from application.models import Item
head = Item.objects(item_id=self.head).first()
if not head: return True
if self.modified != head.modified:return True
return False
class OrderExtra(db.Document):
meta = {
'indexes': [
'order', 'paid_date', 'device_id', 'client', 'version',
'client_channel'
]
}
order = db.ReferenceField('Order', unique=True)
paid_date = db.DateTimeField()
client = db.StringField()
version = db.StringField()
device_id = db.StringField()
client_channel = db.StringField()
class Banner(db.Document):
meta = {'db_alias': 'content_db', 'indexes': ['published']}
created_at = db.DateTimeField(default=datetime.datetime.utcnow,
required=True)
banner_type = db.StringField(default="BOARD", choices=['BOARD', 'URL'])
target = db.StringField()
img = db.StringField()
date_from = db.DateTimeField(default=datetime.datetime.today())
date_until = db.DateTimeField(default=datetime.datetime(2029, 12, 30))
published = db.BooleanField(default=True)
order = db.SequenceField()
def __repr__(self):
return '<Banner object: {}>'.format(str(self.id))
@classmethod
def get_latest(cls, n=10):
now = datetime.datetime.now()
docs = cls.objects(date_from__lte=now, date_until__gt=now).order_by(
'-order', '-created_at').limit(n)
return docs
@property
def target_obj(self):
import application.models as Models
if self.banner_type == 'BOARD':
# if BOARD, return title
return Models.Board.objects(id=self.target).first()
return self.target
def to_json(self):
return {
'type': self.banner_type,
'target': self.target,
'img': self.img,
'created_at': format_date(self.created_at),
}
class ItemSpecSnapshot(db.DynamicDocument):
meta = {
'db_alias': 'order_db',
'indexes': ['item_id', 'sku', 'head']
}
head = db.IntField(required=True, default=0)
item = db.ReferenceField('ItemSnapshot')
created_at = db.DateTimeField(default=datetime.datetime.utcnow())
def __unicode__(self):
return '%s:%s' % (self.item.head, self.head)
@classmethod
def create(cls, spec, itemsnapshot=None):
if not itemsnapshot:
itemsnapshot = ItemSnapshot.create(spec.item).save()
data = spec._data
shot = cls(**data)
shot.head = shot.sku
shot.item = itemsnapshot
shot.save()
itemsnapshot.specs.append(shot)
itemsnapshot.save()
return shot
def update_to_head(self):
from application.models import ItemSpec
head = ItemSpec.objects(sku=self.head).first()
if self.item and isinstance(self.item, ItemSnapshot):
self.item.update_to_head()
if head:
data = head._data
for k, v in data.items():
setattr(self, k, v)
self.save()
else:
return self
@property
def is_changed(self):
from application.models import ItemSpec
head = ItemSpec.objects(sku=self.head).first()
if not head: return True
if self.modified != head.modified: return True
return False
class LogisticLog(db.Document):
meta = {
'db_alias': 'log_db',
'allow_inheritance': True,
'indexes': ['logistic_id', 'timestamp'],
'ordering': ['-timestamp'],
}
log_type = db.StringField()
logistic_id = db.ObjectIdField(required=True)
timestamp = db.DateTimeField(default=datetime.utcnow)
user_id = db.StringField(required=False)
info = db.DictField()
@classmethod
def create(cls, log, data, user_id='system'):
return cls(logistic_id=log.id, info=data, user_id=user_id).save()
class PostFeedback(db.Document):
meta = {
'db_alias': 'content_db',
'indexes': ['user_id', 'post', 'subject', 'created_at'],
'ordering': ['created_at']
}
user_id = db.ObjectIdField()
post = db.ReferenceField('Post')
subject = db.StringField()
status = db.StringField(default=ACTIVITY_STATUS.PENDING,
choices=ACTIVITY_STATUS)
created_at = db.DateTimeField(default=datetime.utcnow, required=True)
@property
def user(self):
from application import models as Models
return Models.User.objects(id=self.user_id).first()
class PostActivity(db.Document):
meta = {
'db_alias': 'content_db',
'indexes': ['user_id', 'to_user_id', 'post', 'created_at', 'action'],
'ordering': ['-created_at']
}
user_id = db.ObjectIdField()
post = db.ReferenceField('Post')
action = db.StringField(choices=NOTI_TYPE)
created_at = db.DateTimeField(default=datetime.utcnow, required=True)
to_user_id = db.ObjectIdField()
info = db.StringField(default="")
@property
def user(self):
from application import models as Models
return Models.User.objects(id=self.user_id).first()
@property
def to_user(self):
from application import models as Models
return Models.User.objects(id=self.to_user_id).first()
def to_json(self):
user = self.user
return dict(
id=str(self.id),
user=dict(id=str(user.id),
name=user.name,
avatar_url=user.avatar_url,
avatar_thumb=user.avatar_thumb),
)
@classmethod
def create(cls, user, to_user, post, action, info=''):
noti = cls(user_id=user,
to_user_id=to_user,
action=action,
info=info,
post=post).save()
return noti
class CartEntry(db.Document):
meta = {
'db_alias': 'cart_db'
}
item_id = db.StringField(required=True)
title = db.StringField()
primary_img = db.StringField()
price = db.FloatField()
created_at = db.DateTimeField(default=datetime.utcnow)
def __unicode__(self):
return '%s' % str(self.id)
@property
def fields(self):
return ['item_id', 'title', 'primary_img', 'price', 'created_at']
def to_json(self):
result = {f: getattr(self, f) for f in self.fields}
return result
class PostTag(db.Document):
meta = {
'db_alias': 'content_db',
'indexes': ['name', 'kind', 'created_at'],
'ordering': ['created_at']
}
name = db.StringField(required=True, unique=True)
bg_color = db.StringField(default="#f8f8f8")
font_color = db.StringField(default="#444")
kind = db.StringField(required=True,
choices=POST_TAG_TYPES,
default=POST_TAG_TYPES.UNCLASSIFIED)
created_at = db.DateTimeField(default=datetime.utcnow, required=True)
def __unicode__(self):
return u'%s' % self.name
@classmethod
def get_tag_or_create(cls, name, kind=POST_TAG_TYPES.UNCLASSIFIED):
if not cls.objects(name=name):
bg_color, font_color = None, None
if kind == POST_TAG_TYPES.TRADE:
bg_color = "#e6b500"
font_color = "#fff"
elif kind == POST_TAG_TYPES.SERVICE:
bg_color = "#EA004F"
font_color = "#fff"
elif kind == POST_TAG_TYPES.SHOW:
bg_color = "#0a9dc7"
font_color = "#fff"
else:
bg_color = "#f8f8f8"
font_color = "#444"
cls(name=name, kind=kind, bg_color=bg_color,
font_color=font_color).save()
def to_json(self):
return dict(name=self.name,
bg_color=self.bg_color,
font_color=self.font_color)
class ForexRate(db.Document):
currency = db.StringField(default=CURRENCY.USD, choices=CURRENCY)
rate = db.FloatField()
modified = db.DateTimeField()
@classmethod
def get(cls, currency=CURRENCY.USD):
currency = currency.upper()
if currency == 'US':
currency = 'USD'
if currency == 'CNY':
return 1
# rounding datetime, so we can use cache of mongoengine
start = (datetime.utcnow() - timedelta(days=3)).replace(minute=0,
second=0,
microsecond=0)
rate_objs = cls.objects(currency=currency, modified__gt=start)
rates = [r.rate for r in rate_objs]
try:
rate = sum(rates) / float(len(rates))
except ZeroDivisionError:
rate = 0
if not rate:
rate = cls.get_latest_rate(currency)
return _ceil(rate + RATE_INCR.get(currency, 0), 3)
@classmethod
def get_latest_rate(cls, currency=CURRENCY.USD):
forex = cls.objects(currency=currency).order_by('-modified').first()
rate = forex.rate if forex else DEFAULT_RX_RATE[currency]
return rate
@classmethod
def put(cls, rate, d=None, currency=CURRENCY.USD):
if d is None:
d = datetime.utcnow()
cls.objects(currency=currency, modified=d).update_one(set__rate=rate,
upsert=True)
class Trade(db.Document):
meta = {
'indexes': ['wallet', 'user', 'time', 'kind', 'reason_id', 'reason'],
'ordering': ['wallet'],
'allow_inheritance': True,
}
user = db.ReferenceField('User')
wallet = db.ReferenceField(CoinWallet)
amount = db.IntField(required=True)
coin_type = db.StringField(choices=COIN_TYPE, default=COIN_TYPE.COIN)
time = db.DateTimeField(required=True)
kind = db.StringField(required=True, choices=tuple(COIN_TRADE_TYPE))
reason = db.StringField(required=True, choices=tuple(COIN_TRADE_REASON))
reason_id = db.StringField()
description = db.StringField()
is_hold = db.BooleanField()
descs = {
'PAY': u'购买',
'CANCEL': u'取消订单',
'SHIPPING_FEE': u'返还运费',
'PROMOTE': u'参与活动',
'WECHAT_LOGIN': u'微信账号登陆',
'IOS_APP': u'下载手机客户端',
'VERIFIED_ID': u'上传身份证资料',
'SHARED': u'分享了一个链接',
'SECOND_SHARED': u'你的链接被分享了',
'SHARED_ORDER': u'通过你的链接购买',
'ORDER': u'订单完成',
'OTHER': u'其他',
}
def clean(self):
if not self.description:
self.description = self.descs.get(self.reason, '')
class Price(db.EmbeddedDocument):
price = db.FloatField()
record_date = db.DateTimeField()
class CartEntry(db.EmbeddedDocument):
sku = db.IntField(required=True)
quantity = db.IntField(default=1, required=True)
created_at = db.DateTimeField()
first_price = db.FloatField(default=0)
class Item(db.Document):
meta = {'db_alias': 'inventory_db'}
owner = db.StringField()
owner_id = db.StringField()
item_id = db.StringField(primary_key=True) # id
eth_token = db.StringField()
## price
price = db.FloatField()
primary_img = db.StringField()
images = db.ListField(db.StringField())
# basic information
title = db.StringField()
brand = db.StringField()
condition = db.StringField()
description = db.StringField(default='')
madein = db.StringField()
#color = db.ListField(db.StringField())
location = db.StringField()
main_category = db.StringField()
sub_category = db.StringField()
sex_tag = db.StringField()
tags = db.ListField(db.StringField())
availability = db.BooleanField(default=True)
state = db.StringField()
# time
created_at = db.DateTimeField(default=datetime.utcnow)
modified = db.DateTimeField()
creator = db.StringField()
def __unicode__(self):
return '%s' % self.item_id
def __repr__(self):
return '%s' % self.item_id
@property
def cart_fields(self):
return ['item_id', 'title', 'primary_img', 'price']
def to_cart(self):
result = {f: getattr(self, f) for f in self.cart_fields}
return result
@db.queryset_manager
def available_items(doc_cls, queryset):
return queryset.filter(availability=True)
@property
def small_thumbnail(self):
return self.primary_img[:23] + 'thumbnails/150x150/' + self.primary_img[
23:]
@property
def large_thumbnail(self):
return self.primary_img[:23] + 'thumbnails/400x400/' + self.primary_img[
23:]
@classmethod
def create(cls, item):
item = Item(**item).save()
item_id = item.item_id
return item_id
class Board(db.Document):
meta = {
'db_alias': 'content_db',
'indexes': ['published_at', 'title'],
'ordering': ['-published_at']
}
title = db.StringField(required=True)
description = db.StringField()
status = db.StringField(default="PENDING", choices=["PUBLISHED", "PENDING"])
board_type = db.StringField()
items = db.ListField(db.StringField())
image = db.StringField()
author = db.StringField()
participants = db.ListField(db.StringField())
view_count = db.IntField(default=0)
created_at = db.DateTimeField(default=datetime.utcnow)
modified = db.DateTimeField()
published_at = db.DateTimeField()
expired_date = db.DateTimeField()
def __unicode__(self):
return '%s' % str(self.id)
@classmethod
def create(cls, user, board_type):
default_title = str(datetime.utcnow().date())
b = Board(
title=default_title,
author=user,
board_type=board_type,
participants=[user])
b._add_log(user, 'NEW')
b.save()
@classmethod
def get_board(cls, board_id):
return cls.objects(id=board_id).first()
def add_item(self, user, item):
self._add_remove_item(user, 'ADD', item)
def remove_item(self, user, item):
self._add_remove_item(user, 'REMOVE', item)
def publish(self, user):
self.status = "PUBLISHED"
self.published_at = datetime.utcnow()
self._add_log(user, 'PUBLISH')
def unpublish(self, user):
self.status = "PENDING"
self.published_at = None
self._add_log(user, 'UNPUBLISH')
def reorder_item(self, item, index):
self.items.remove(item)
self.items.insert(index, item)
def add_comment(self, user, comment):
self._add_log(user, 'COMMENT', info=comment)
def _add_remove_item(self, user, action, item):
if not item in self.items:
self.items.append(item)
else:
self.items.remove(item)
self._add_log(user, action, item)
def _add_log(self, user, action, item=None, info=''):
if not user in self.participants:
self.participants.append(user)
self.logs.insert(0, ChangeLog(user=user, action=action,
item=item, info=info))
self.save()
def to_json(self):
return dict(
id=str(self.id),
date=str(self.published_at),
image=self.image,
desc=self.description,
title=self.title,
)
class ExpressTracking(db.Document):
company = db.StringField(required=True)
number = db.StringField(required=True, unique_with='company')
to = db.StringField()
ischeck = db.StringField(required=True, default='0')
# 快递单当前签收状态，包括0在途中、1已揽收、2疑难、3已签收、4退签、5同城派送中、
# 6退回、7转单等7个状态
state = db.StringField()
# Dictionary in data
# {
# "context":"上海分拨中心/下车扫描 ", /*内容*/
# "time":"2012-08-27 23:22:42", /*时间，原始格式*/
# "ftime":"2012-08-27 23:22:42", /*格式化后时间*/
# "status":"在途",
# "areaCode":"310000000000",
# "areaName":"上海市",
# }
data = db.ListField(db.DictField())
# time
created_at = db.DateTimeField(default=datetime.utcnow, required=True)
is_subscribed = db.BooleanField(default=False)
modified = db.DateTimeField()
retries = db.IntField(default=0)
@classmethod
def find(cls, company, number):
cls.objects(company=company,
number=number).update_one(set__company=company,
set__number=number,
upsert=True)
return cls.objects.get(company=company, number=number)
@classmethod
def subscribed(cls, company, number):
obj = cls.objects(company=company, number=number, is_subscribed=True)
return True if obj else False
@classmethod
def update_info(cls, data):
cls.objects(company=data['com'], number=data['nu']).update_one(
set__ischeck=data['ischeck'],
set__state=STATE.get(data['state']),
set__data=data['data'],
set__modified=datetime.utcnow(),
upsert=True)
@property
def is_checked(self):
if self.ischeck and self.ischeck == '0':
return False
elif self.ischeck == '1':
return True
@property
def history(self):
result = []
for d in self.data:
formated = {
k: v
for k, v in d.items() if k in ['ftime', 'context']
}
result.append(formated)
return result
def to_json(self):
return dict(company=self.company,
number=self.number,
ischeck=self.ischeck,
state=self.state,
data=self.data)
class ExpressRequestLog(db.Document):
created_at = db.DateTimeField(default=datetime.utcnow, required=True)
company = db.StringField()
number = db.StringField()
respond = db.DictField()
is_success = db.BooleanField()
