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 ChannelProvider(db.Document):
meta = {'db_alias': 'order_db'}
name = db.StringField()
display_name = db.StringField()
description = db.StringField()
service_intro = db.DictField()
country = db.StringField()
is_active = db.BooleanField(default=False)
shipping = db.FloatField(required=True)
is_recommended = db.BooleanField(default=False)
def __repr__(self):
return '<ChannelProvider {}>'.format(self.name)
@classmethod
def get_shipping(cls, channel_name, country):
if not channel_name:
channel_name = 'default'
provider = cls.objects(name=channel_name, country=country).first()
return provider.shipping
@queryset_manager
def active(doc_cls, queryset):
return queryset.filter(is_active=True)
def to_json(self):
return dict(name=self.name,
display_name=self.display_name,
service_intro=self.service_intro,
desc=self.description)
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 LogisticProvider(db.Document, WeightPrice):
meta = {
'db_alias': 'order_db'
}
name = db.StringField()
display_name = db.StringField()
description = db.StringField()
service_intro = db.DictField()
logo = db.StringField()
country = db.StringField()
is_active = db.BooleanField(default=False)
rule_desc = db.StringField()
init_price = db.FloatField(required=True)
init_weight = db.IntField(required=True)
continued_price = db.FloatField(required=True)
continued_weight = db.IntField(required=True)
init_coin = db.IntField(default=0)
features = db.ListField(db.StringField())
promotion = db.StringField(default='')
limited_weight = db.IntField(required=True)
limited_category = db.ListField(db.StringField())
is_recommended = db.BooleanField(default=False)
rating = db.DecimalField(precision=1)
rating_users = db.IntField()
def __repr__(self):
return '<LogisticProvider {}>'.format(self.name)
# TODO: memoize here
@classmethod
def get_provider_shipping(cls, logistic_name, country, weight):
if not logistic_name:
logistic_name = 'default'
provider = cls.objects(name=logistic_name, country=country).first()
return provider.get_shipping(weight)
@queryset_manager
def active(doc_cls, queryset):
return queryset.filter(is_active=True)
def to_json(self):
return dict(
name = self.name,
display_name = self.display_name,
service_intro = self.service_intro,
desc = self.description)
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 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 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 Data(db.Document):
meta = {
'db_alias': 'data_db',
}
sku = db.IntField(required=True, unique=True)
item_id = db.IntField()
title = db.StringField()
primary_image = db.StringField()
item_available = db.BooleanField()
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 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 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 Post(db.Document):
meta = {
'db_alias':
'content_db',
'indexes': [
'post_id', 'user_id', 'title', 'post_type', 'location', 'tags',
'num_views', 'created_at'
],
'ordering': ['-created_at']
}
post_id = db.SequenceField(required=True, unique=True,
primary_key=True) # id
primary_image = db.StringField()
images = db.ListField(db.StringField())
tags = db.ListField(db.StringField())
title = db.StringField(default='')
location = db.PointField()
location_extra = db.DictField()
post_type = db.StringField(default=POST_TAG_TYPES.SHOW,
choices=POST_TAG_TYPES)
# extra
num_likes = db.IntField(default=0)
num_comments = db.IntField(default=0)
num_views = db.IntField(default=0)
status = db.StringField(default=POST_STATUS.NEW,
required=True,
choices=POST_STATUS)
approved = db.BooleanField(default=True, required=True)
# time
created_at = db.DateTimeField(default=datetime.utcnow, required=True)
modified = db.DateTimeField()
user_id = db.ObjectIdField()
def __unicode__(self):
return '%s' % self.post_id
def __repr__(self):
return '%s' % self.post_id
@db.queryset_manager
def approved_posts(doc_cls, queryset):
return queryset.filter(approved=True)
@classmethod
def create(cls, post):
for tag in post['tags']:
PostTag.get_tag_or_create(tag)
post = Post(**post)
post.approved = False
post.save()
post_id = post.post_id
return post_id
@classmethod
def modify(cls, new_post):
# If the post does not exist in our db, then do not trust the coming
# mod data.
try:
old_post = Post.objects.get(post_id=new_post['post_id'])
old_post.status = POST_STATUS.MOD
except DoesNotExist:
current_app.logger.warning(
'does not exist in db: {}'.format(new_post))
return
for k, v in new_post.items():
setattr(old_post, k, v)
old_post.save()
return old_post.post_id
@classmethod
def delete_post(cls, post_id):
try:
post = cls.objects.get(id=post_id)
post.status = 'DEL'
post.approved = False
post.save()
return post.post_id
except DoesNotExist:
pass
@property
def small_thumbnail(self):
return self.primary_image[:
23] + 'post_thumbs/180x180/' + self.primary_image[
23:]
@property
def large_thumbnail(self):
return self.primary_image[:
23] + 'post_thumbs/480x480/' + self.primary_image[
23:]
@property
def user(self):
from application import models as Models
return Models.User.objects(id=self.user_id).first()
def to_simple_json(self):
type_map = {
"SHOW": u"心情",
"SERVICE": u"服务",
"TRADE": u"买卖",
}
type_dt = {'en': self.post_type, 'cn': type_map[self.post_type]}
return dict(post_id=str(self.post_id),
title=self.title,
type=type_dt,
primary_image=self.primary_image,
large_url=self.large_thumbnail,
small_url=self.small_thumbnail,
images=self.images,
created_at=self.created_at.strftime("%Y-%m-%dT%H:%M:%S Z"),
num_likes=self.num_likes,
num_comments=self.num_comments,
num_views=self.num_views,
tags=self.tags,
status=self.status)
class Logistic(db.Document):
meta = {
'db_alias': 'order_db',
'indexes': ['is_closed', '-created_at',
'order', 'entries',
'detail.status',
'detail.channel',
'detail.modified',
'detail.cn_tracking_no',
'detail.cn_logistic_name',
'detail.payment_received_date',
'detail.processing_date',
'detail.shipping_date',
'detail.port_arrived_date',
'detail.received_date',
'detail.partner',
'detail.partner_tracking_no',
('detail.status', '-created_at'),
]
}
order = db.ReferenceField('Order', required=True)
entries = db.ListField(db.ReferenceField('OrderEntry'))
returned_entries = db.ListField(db.ReferenceField('OrderEntry'))
is_closed = db.BooleanField(default=False, required=True)
close_reason = db.StringField()
closed_at = db.DateTimeField()
created_at = db.DateTimeField(
required=True, default=datetime.datetime.utcnow
)
detail = db.EmbeddedDocumentField('LogisticDetail')
def __unicode__(self):
return '%s' % str(self.id)
@property
def estimated_weight(self):
return sum(float(entry.item_snapshot.weight) * entry.quantity
for entry in self.entries)
def to_json(self):
detail = self.detail
return dict(cn_tracking_no=detail.cn_tracking_no,
cn_logistic_name=detail.cn_logistic_name,
partner_tracking_no=detail.partner_tracking_no,
partner_name=detail.partner.name if detail.partner else '',
payment_received_date=get_date(detail, 'payment_received_date'),
processing_date=get_date(detail, 'processing_date'),
shipping_date=get_date(detail, 'shipping_date'),
port_arrived_date=get_date(detail, 'port_arrived_date'),
received_date=get_date(detail, 'received_date'),
estimated_weight=self.estimated_weight,
real_weight=detail.real_weight,
status=detail.status)
@property
def amount(self):
return sum(entry.amount for entry in self.entries)
@property
def amount_usd(self):
return sum(entry.amount_usd for entry in self.entries)
@classmethod
def create(cls, order):
from application.models.order.partner import Partner
def update_order(o):
o.logistics.append(log)
o.save()
o.update_logistic_status()
def create_logistic(order):
log = cls(detail=LogisticDetail())
log.order = order
log.entries = order.entries
log.detail.partner = Partner.objects().first()
log.detail.partner_tracking_no = gen_uid()
log.detail.status = order.status
date_field = log.detail.attr_by_log_stat[order.status]
setattr(log.detail, date_field, datetime.datetime.utcnow())
log.save()
return log
log = create_logistic(order)
update_order(order)
return log
@classmethod
def merge_with(cls, los):
if not type(los) is list:
return False
start = 0
for index in range(len(los)-1):
if los[index+1].detail.cn_tracking_no != \
los[start].detail.cn_tracking_no or \
los[index+1].order != los[0].order :
return False
for index in range(len(los)-1):
map(lambda e: los[index+1].entries.append(e),
los[index].entries)
los[index].entries = []
los[index].save()
los[index].close(
'merged with %s' %
los[index+1].id, datetime.datetime.utcnow()
)
los[index+1].save()
if index+1 == len(los)-1:
comment = LogisticRemark(
content=u"合并单", creator=current_user.name
)
los[index+1].detail.remarks.append(comment)
los[index+1].save()
return los[index+1]
def close(self, reason, time=None):
self.is_closed = True
self.close_reason = reason
self.closed_at = time or datetime.datetime.utcnow()
self.save()
order = self.order
if self in order.logistics:
order.logistics.remove(self)
order.closed_logistics.append(self)
order.save()
def fork_by_entries(self, entry_ids):
def get_entry(entries, eid):
for e in entries:
if str(eid) == str(e.id):
return e
return False
if not type(entry_ids) is list:
return False
if len(self.entries) < 2:
return False
if self.detail.status != 'PAYMENT_RECEIVED':
self.detail.status = 'PROCESSING'
self.detail.processing_date = datetime.datetime.utcnow()
self.save()
forked_order = Logistic(detail=self.detail)
entries = [get_entry(self.entries, e) for e in entry_ids]
if not entries:
False
forked_order.entries = entries
forked_order.order = self.order
forked_order.save()
self.order.logistics.append(forked_order)
self.order.save()
map(lambda e: self.entries.remove(e), entries)
self.save()
old_ptn = self.detail.partner_tracking_no
new_ptn = gen_uid()
forked_order.detail.partner_tracking_no = new_ptn
remark = u"%s拆出了%s" % (old_ptn, new_ptn)
forked_order.update_remark(remark, current_user.name)
self.update_remark(remark, current_user.name)
return self, forked_order
def update_status(self, new_status):
try:
index = LOG_STATS.index(new_status)
except ValueError:
return
log = self.detail
old_status = log.status
if index > LOG_STATS.index(old_status):
log.status = new_status
now = datetime.datetime.utcnow()
date_field = log.attr_by_log_stat[new_status]
if not getattr(log, date_field):
setattr(log, date_field, now)
self.save()
self.order.update_logistic_status()
def update_logistic(self, info):
log = self.detail
next_status = info.get('status', '')
require = {
'SHIPPING': ['cn_tracking_no', 'cn_logistic_name'],
}
if next_status in require.keys():
values = require[next_status]
for value in values:
if value in info:
continue
value = getattr(self.detail, value)
if value in [None, '', 'None', '?', u'?', u'None',
'Undefined', u'Undefined']:
raise Exception("Fail to update logistic")
if current_user and not current_user.is_anonymous:
modified_by = current_user.name
else:
modified_by = 'system'
self.update_status(next_status)
remark = info.get('remark', None)
if remark:
self.update_remark(remark, modified_by)
delay_content = info.get('delay', None)
if delay_content:
self.update_delay(delay_content, modified_by)
irregularity = info.get('irregularity', None)
if irregularity:
self.update_irregularity(irregularity, modified_by)
for field, value in info.items():
if field in ['status']:
continue
setattr(log, field, value)
self.save()
Signals.logistic_stat_changed.send(
'send to logistic partner', lo=self, status=next_status)
Signals.logistic_info_updated.send('system', logistic=self)
def update_remark(self, content, modified_by):
remark = LogisticRemark(content=content, creator=modified_by)
self.detail.remarks.append(remark)
self.save()
def update_delay(self, content, modified_by):
delays = self.detail.delay_details.filter(status=self.detail.status)
if delays:
delays.update(reason=content, creator=modified_by)
else:
delay = LogisticDelay(
reason=content, creator=modified_by,
status=self.detail.status
)
self.detail.delay_details.append(delay)
remark = LogisticRemark(content=content, creator=modified_by)
self.detail.remarks.append(remark)
self.save()
def update_irregularity(self, irregularity, modified_by):
irregularity.creator = modified_by
self.detail.irregular_details.append(irregularity)
self.save()
@property
def shipping_history(self):
res = []
status = self.detail.status
for st in LOG_STATS:
field = self.detail.attr_by_log_stat[st]
val = getattr(self.detail, field)
if not val:
continue
res.append({'time': format_date(val),
'desc': SHIPPING_HISTORY[st],
'status': st})
if st == status:
break
return res
@property
def express_tracking(self):
import application.models as Models
com = self.detail.cn_logistic_name
nu = self.detail.cn_tracking_no
if com and nu:
tracking = Models.ExpressTracking.find(
company=com,
number=nu)
return tracking
return None
@classmethod
def pre_save_post_validation(cls, sender, document, **kwargs):
if not kwargs['created']:
old_log = cls.objects(id=document.id).first().detail
new_log = document.detail
for field in LogisticDetail._fields:
if field == 'modified':
continue
if (getattr(old_log, field) != getattr(new_log, field)):
new_log.modified = datetime.datetime.utcnow()
if current_user and not current_user.is_anonymous:
new_log.modified_by = current_user.name
else:
new_log.modified_by = 'system'
return
else:
document.detail.modified = datetime.datetime.utcnow()
class LogisticDelay(db.EmbeddedDocument):
reason = db.StringField()
is_done = db.BooleanField(default=False)
status = db.StringField(choices=LOG_STATS)
creator = db.StringField()
created_at = db.DateTimeField(default=datetime.datetime.utcnow)
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 Order(db.Document):
meta = {
'db_alias':
'order_db',
'ordering': ['-created_at'],
'indexes': [
'customer_id', 'short_id', 'created_at', 'status', 'address',
'amount', 'final', 'order_type', 'is_paid', 'is_payment_abnormal',
'refund_entries'
]
}
created_at = db.DateTimeField(default=datetime.datetime.utcnow,
required=True)
order_type = db.StringField(choices=ORDER_TYPE,
default=ORDER_TYPE.COMMODITY)
expired_in = db.IntField(default=1440) # in minutes
payment_expired_in = db.IntField(
default=1440) # minutes before payment should expire
short_id = db.SequenceField(required=True, unique=True)
is_vip = db.BooleanField(default=False)
status = db.StringField(max_length=255,
required=True,
choices=ORDER_STATUS,
default=ORDER_STATUS.PAYMENT_PENDING)
status_modified = db.DateTimeField()
source = db.StringField(choices=ORDER_SOURCES)
is_rewards_given = db.BooleanField(default=False)
# order detail
amount_usd = db.FloatField(default=0)
amount = db.FloatField(default=0)
discount = db.ListField(db.DictField()) # only for coupon
coupon_codes = db.ListField(db.StringField())
coin = db.IntField()
hongbao = db.IntField()
cash = db.IntField()
final = db.FloatField(required=True)
logistic_provider = db.StringField()
estimated_tax = db.FloatField(default=0)
real_tax = db.FloatField(default=-1)
paid_tax = db.FloatField(default=-1)
# for internal usage
forex = db.FloatField()
real_shipping = db.FloatField() # real shipping fee paid
cn_shipping = db.FloatField(default=0)
address = db.ReferenceField('Address')
customer_id = db.ObjectIdField(required=True)
is_new_customer = db.BooleanField(default=False)
entries = db.ListField(
db.ReferenceField('OrderEntry', reverse_delete_rule=mongoengine.PULL))
extra = db.StringField()
# keep old property it here for migration
logistics = db.ListField(db.ReferenceField('Logistic'))
closed_logistics = db.ListField(db.ReferenceField('Logistic'))
# this doesn't indicate whether customer have paid tax or not
is_paid = db.BooleanField(default=False)
is_payment_abnormal = db.BooleanField(default=False)
paid_date = db.DateTimeField()
pay_tax_deadline = db.DateTimeField()
# informations of refundation
refund_entries = db.ListField(
db.ReferenceField('OrderEntry', reverse_delete_rule=mongoengine.PULL))
refund_amount = db.FloatField(default=0)
is_test = db.BooleanField(default=False)
fields_to_log = {
'status',
'amount',
'coin',
'final',
'estimated_tax',
'real_tax',
'paid_tax',
'real_shipping',
'is_paid',
}
PROCESSING_STATUS = [ORDER_STATUS.PAYMENT_RECEIVED, ORDER_STATUS.SHIPPING]
ABNORMAL_STATUS = [
ORDER_STATUS.CANCELLED, ORDER_STATUS.ABNORMAL,
ORDER_STATUS.ORDER_DELETED, ORDER_STATUS.EXPIRED, ORDER_STATUS.REFUNDED
]
def __unicode__(self):
return '%s' % self.sid
@classmethod
def get_order_or_404(cls, order_id, check_user=True):
try:
order = cls.objects(id=order_id).first_or_404()
except mongoengine.ValidationError:
try:
short_id = int(order_id)
except (ValueError, TypeError):
abort(404)
order = cls.objects(short_id=short_id).first_or_404()
if check_user and str(order.customer_id) != str(current_user.id):
abort(404)
return order
@queryset_manager
def commodities(doc_cls, queryset):
return queryset.filter(order_type=ORDER_TYPE.COMMODITY,
status__nin=doc_cls.ABNORMAL_STATUS)
@queryset_manager
def transfer(doc_cls, queryset):
return queryset.filter(order_type=ORDER_TYPE.TRANSFER,
status__nin=doc_cls.ABNORMAL_STATUS)
@queryset_manager
def processing(doc_cls, queryset):
return queryset.filter(status__in=doc_cls.PROCESSING_STATUS)
@queryset_manager
def payment_pending(doc_cls, queryset):
return queryset.filter(status=ORDER_STATUS.PAYMENT_PENDING)
@queryset_manager
def abnormal(doc_cls, queryset):
''' Define abnormal: status is abnormal, or partial entries are refunded.'''
return queryset.filter(
Q(status__in=doc_cls.ABNORMAL_STATUS) | \
(Q(refund_entries__0__exists=True) & Q(status__in=(doc_cls.PROCESSING_STATUS+[ORDER_STATUS.RECEIVED])))
)
@queryset_manager
def received(doc_cls, queryset):
return queryset.filter(status=ORDER_STATUS.RECEIVED)
def is_processing(self):
return self.status in self.PROCESSING_STATUS
def is_payment_pending(self):
return self.status == ORDER_STATUS.PAYMENT_PENDING
def is_abnormal(self):
if self.status in self.ABNORMAL_STATUS:
return True
if self.status in self.PROCESSING_STATUS or self.status == ORDER_STATUS.RECEIVED:
return len(self.refund_entries) > 0
return False
def has_refund_entries(self):
if self.status in (self.PROCESSING_STATUS +
[ORDER_STATUS.RECEIVED, ORDER_STATUS.REFUNDED]):
return len(self.refund_entries) > 0
return False
@property
def tax(self):
if self.real_tax == -1:
return self.estimated_tax
else:
return self.real_tax
@property
def shipping(self):
return self.cn_shipping
@property
def estimated_weight(self):
return sum(
float(entry.item_snapshot.weight) * entry.quantity
for entry in self.entries)
@property
def pay_tax_remain_days(self):
if self.pay_tax_deadline:
time_remain = self.pay_tax_deadline.date() - datetime.date.today()
if time_remain.days > 0:
return time_remain.days
@property
def latest_logistic(self):
from application.models import LogisticDetail
attr = LogisticDetail.attr_by_log_stat.get(self.status)
if not attr:
return None
return max(self.logistics, key=lambda l: getattr(l.detail, attr))
@classmethod
def create_transfer(cls,
customer_id,
entries,
logistic_provider,
coupon_codes,
coin=0,
cash=0,
address=None,
**kwargs):
from application.models import ForexRate
order = cls(customer_id=customer_id,
entries=entries,
logistic_provider=logistic_provider,
coupon_codes=coupon_codes,
coin=coin,
cash=cash,
**kwargs)
if not order.forex:
order.forex = ForexRate.get()
order.update_amount()
order.reload()
if address:
order.set_address(address)
import application.services.jobs as Jobs
#Jobs.stat.update_user_stats(str(order.customer_id))
Signals.order_created.send('system', order=order)
return order
@classmethod
def create_from_skus(cls,
customer_id,
skus,
logistic_provider,
coupon_codes,
coin=0,
cash=0,
address=None,
**kwargs):
from application.models import OrderEntry, ForexRate, Item, ItemSpec
entries = []
for e in skus:
availability = check_availability_and_update_stock(
e['item_id'], e['sku'], e['quantity'])
if not availability:
return e
spec = ItemSpec.objects(sku=e['sku']).first()
item = Item.objects(item_id=e['item_id']).first()
entry = OrderEntry(spec=spec, item=item,
quantity=e['quantity']).save()
entries.append(entry)
order = cls(customer_id=customer_id,
entries=entries,
logistic_provider=logistic_provider,
coupon_codes=coupon_codes,
coin=coin,
cash=cash,
**kwargs)
if not order.forex:
order.forex = ForexRate.get()
order.update_amount()
order.reload()
for e in order.entries:
e.create_snapshot()
if address:
order.set_address(address)
import application.services.jobs as Jobs
#Jobs.stat.update_user_stats(str(order.customer_id))
Signals.order_created.send('system', order=order)
return order
@classmethod
def create(cls,
customer_id,
entries,
logistic_provider,
coupon_codes,
coin=0,
cash=0,
address=None,
**kwargs):
import application.models as Models
order_entries = []
for entry in entries:
availability = check_availability_and_update_stock(
entry.item_snapshot.item_id, entry.item_spec_snapshot.sku,
entry.quantity)
if not availability:
return entry
if isinstance(entry, (Models.CartEntry, Models.OrderEntry)):
e = deepcopy(entry)
e.__class__ = Models.OrderEntry
e.id = None
order_entries.append(e.save())
# entry.delete()
order = cls(customer_id=customer_id,
entries=order_entries,
logistic_provider=logistic_provider,
coupon_codes=coupon_codes,
coin=coin,
cash=cash,
**kwargs)
if not order.forex:
order.forex = Models.ForexRate.get()
order.update_amount()
order.reload()
for e in order.entries:
e.create_snapshot()
if address:
order.set_address(address)
import application.services.jobs as Jobs
#Jobs.stat.update_user_stats(str(order.customer_id))
Signals.order_created.send('system', order=order)
return order
@property
def item_changed(self):
res = False
for e in entries:
res = res and e.item_changed
if res: return res
return res
def __get__(self, *args, **kwargs):
order = super(Order, self).__get__(*args, **kwargs)
if (not order.is_paid) and order.item_changed: order.update_entry()
return order
def update_entry(self):
if self.is_paid: return
map(lambda e: e.update_snapshot(), self.entries)
self.update_amount()
def set_address(self, addr):
''' Create a snapshot of `addr` and make it the address of `self`.
It's important to creat a snapshot instead of referencing to the
origin address object such that the detail of order's address can
not be modified. '''
from application.models import Address
if not isinstance(addr, Address):
addr = Address.objects(id=addr).first()
if not addr:
return False
addr_snapshot = deepcopy(addr)
addr_snapshot.id = None
addr_snapshot.order_id = self.id
addr_snapshot.save()
if self.address:
self.address.delete(w=1)
self.address = addr_snapshot
self.save()
return True
@property
def customer(self):
from application import models as Models
return Models.User.objects(id=self.customer_id).first()
def create_payment(self, ptype, trader):
ptype = ptype.upper()
self.update_entry()
self.reload()
if self.order_type != ORDER_TYPE.TRANSFER:
is_available = self.check_entries_avaliable()
if not is_available or self.status in [
'CANCELLED', 'ABNORMAL', 'ORDER_DELETED', 'EXPIRED'
]:
return None
new_payment = Payment(order=self, ptype=ptype, trader=trader).save()
return new_payment
def get_payment(self, ptype):
ptype = ptype.upper()
payments = Payment.objects(order=self,
ptype=ptype).order_by('-created_at')
paid_payments = payments.filter(status=PAYMENT_STATUS.PAID)
if paid_payments:
return paid_payments.first()
else:
return payments.first()
@property
def goods_payment(self):
return self.get_payment(PAYMENT_TYPE.WITHOUT_TAX)
@property
def tax_payment(self):
return self.get_payment(PAYMENT_TYPE.WITH_TAX)
@property
def refunds(self):
from application.models import Refund
return Refund.objects(order=self)
def check_entries_avaliable(self):
availability = all(
map(lambda e: e.is_available or e.item_spec_snapshot.stock != -1,
self.entries))
if not availability:
self.status = ORDER_STATUS.EXPIRED
self.save()
return availability
def set_paid(self):
if self.is_paid:
return
self.is_new_customer = not bool(
Order.objects(customer_id=self.customer_id, is_paid=True))
self.is_paid = True
self.status = ORDER_STATUS.PAYMENT_RECEIVED
self.paid_date = datetime.datetime.utcnow()
self.save()
from application.services.order import payment_received
payment_received(self)
def update_payment(self, paid_type, paid_amount, trader):
if paid_type == PAYMENT_TYPE.WITHOUT_TAX and not self.is_paid and \
self.status in [ORDER_STATUS.PAYMENT_PENDING, ORDER_STATUS.WAREHOUSE_IN]:
if paid_amount == self.final and trader == PAYMENT_TRADERS.PAYPAL:
self.set_paid()
elif paid_amount == float("%.2f" % (self.final * self.forex)) and \
trader == PAYMENT_TRADERS.WEIXIN:
self.set_paid()
else:
current_app.logger.error(
'error at updating payment. trader: {}; ptype: {}; amount:{} order id: {}'
.format(trader, paid_type, paid_amount, self.id))
self.is_payment_abnormal = True
else:
current_app.logger.error(
'error at updating payment. trader: {}; ptype: {}; amount:{} order id: {}'
.format(trader, paid_type, paid_amount, self.id))
self.is_payment_abnormal = True
self.save()
@property
def coin_trades(self):
import application.models as Models
return Models.Trade.objects(reason_id=str(self.id))
def update_logistic_status(self):
if self.logistics:
log_status = map(lambda m: m.detail.status, self.logistics)
new_status = min(log_status, key=lambda l: LOG_STATS.index(l))
self._change_status(new_status)
def _change_status(self, new_status):
from application.services.noti import noti_order
if self.status == new_status:
return
self.status = new_status
self.status_modified = datetime.datetime.utcnow()
self.save()
if new_status in LOG_STATS:
noti_order(self, new_status)
Signals.order_logistic_stat_changed.send(
'Order.Logistic.Status.Changed',
order=self,
new_status=new_status)
else:
Signals.order_status_changed.send('order_status_changed',
order=self,
new_status=new_status)
def delete_order(self):
for mo in self.logistics:
mo.delete(w=1)
for entry in self.entries:
entry.delete(w=1)
import application.services.jobs as Jobs
#Jobs.stat.update_user_stats(str(self.customer_id))
if self.goods_payment:
self.goods_payment.delete(w=1)
self.delete(w=1)
def cancel_order(self, reason, status=None):
for mo in self.logistics:
mo.close(reason)
self.extra = reason
self.save()
if not status:
status = ORDER_STATUS.ABNORMAL
self._change_status(status)
for entry in self.entries:
try:
if entry.spec.stock != -1:
entry.spec.update(inc__stock=entry.quantity,
set__availability=True)
entry.item.update(set__availability=True,
set__status='MOD')
except AttributeError:
pass
def update_amount(self):
from application.services.price import cal_order_price_and_apply, \
cal_order_tax
for e in self.entries:
e.update_amount()
cal_order_price_and_apply(self)
self.estimated_tax = cal_order_tax(self)
self.save()
@property
def sid(self):
return self.short_id
def to_json(self,
include_logistic=False,
replace_entries_to_refunded=False):
if not self.is_paid:
self.update_amount()
self.reload()
entries_json = []
if replace_entries_to_refunded and self.has_refund_entries():
for e in self.refund_entries:
entries_json.append(e.to_json())
else:
for e in self.entries:
entries_json.append(e.to_json())
refund_entries_json = []
for e in self.refund_entries:
refund_entries_json.append(e.to_json())
result = dict(
id=str(self.id),
short_id=str(self.sid),
status=self.status,
customer_id=str(self.customer_id),
amount=self.amount,
cn_shipping=self.cn_shipping,
coin=self.coin,
hongbao=self.hongbao,
discount=self.discount,
final=self.final,
estimated_tax=self.estimated_tax,
payment_status='PAID' if self.is_paid else 'UNPAID',
payment_ref_number=[
p.ref_number for p in Payment.objects(order=self)
],
created_at=format_date(self.created_at),
entries=entries_json,
refund_entries=refund_entries_json,
refund_amount=self.refund_amount,
real_tax=self.real_tax,
)
if self.address:
result.update({"address": self.address.to_json()})
if include_logistic:
result.update(dict(logistics=[l.to_json()
for l in self.logistics]))
return result
def to_grouped_json(self):
res = {
'estimated_weight': self.estimated_weight,
'amount': self.amount,
'cn_shipping': self.cn_shipping,
'coin': self.coin,
'hongbao': self.hongbao,
'discount': self.discount,
'final': self.final,
'estimated_tax': self.estimated_tax
}
res['sid'] = self.sid
res['status'] = self.status
if self.address:
res.update(dict(address=self.address.to_json()))
return res
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()
class User(db.Document, UserMixin):
'''
The User class contains only basic and frequently used information
Superclass UserMixin can provide four authenticate methods required
by Flask-Login.
'''
meta = {
'db_alias': 'user_db',
}
name = db.StringField(required=True)
account = db.EmbeddedDocumentField('UserAccount')
information = db.EmbeddedDocumentField('UserInformation')
selling_items = db.ListField(db.StringField())
sold_items = db.ListField(db.StringField())
owned_item = db.ListField(db.StringField())
bought_item = db.ListField(db.StringField())
roles = db.ListField(db.StringField())
# favor related (item_ids)
num_favors = db.IntField(default=0, min_value=0)
favor_items = db.ListField(db.StringField())
addresses = db.ListField(db.ReferenceField('Address'))
default_address = db.ReferenceField('Address')
verified = db.BooleanField(default=False)
is_deleted = db.BooleanField(default=False)
deleted_date = db.DateTimeField()
def __unicode__(self):
return '%s' % str(self.id)
#return u'{}'.format(self.name)
@property
def avatar_thumb(self):
return self.avatar_url[:23] + 'avatar_thumbs/80x80/' + self.avatar_url[23:]
@db.queryset_manager
def active(doc_cls, queryset):
return queryset.filter(is_deleted=False)
@property
def is_admin(self):
return USER_ROLE.ADMIN in self.roles
@classmethod
def is_verified(self):
return self.verified
def verify(self):
self.verified = True
self.save()
return True
def to_json(self):
data = dict(name=self.name,
created_at=str(self.account.created_at),
id=str(self.id)
)
return data
@classmethod
def authenticate(cls, mobile_number=None, password=None):
if mobile_number:
user = cls.active(account__mobile_number=mobile_number).first()
else:
user = None
if user:
authenticated = user.account.check_password(password)
else:
authenticated = False
return user, authenticated
def generate_auth_token(self, expires_in=604800):
s = Serializer(current_app.config['SECRET_KEY'], expires_in=expires_in)
return s.dumps({'id': str(self.id)}).decode('utf-8')
@staticmethod
def verify_auth_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return None
return User.objects(id=data['id']).first()
@classmethod
def create(cls, mobile_number, password, name, email=None):
# account
account = UserAccount(mobile_number=mobile_number,
email=email,
is_email_verified=True)
account.password = password
user = User(name=name,
roles=[USER_ROLE.MEMBER],
information=UserInformation(),
account=account)
user.save()
signals.user_signup.send('system', user=user)
return user
class Item(db.Document):
meta = {'db_alias': 'inventory_db'}
item_id = db.SequenceField(required=True, unique=True,
primary_key=True) # id
## price
original_price = db.FloatField(required=True, min_value=0)
price = db.FloatField(required=True, min_value=0)
discount = db.IntField()
primary_img = db.StringField(required=True)
# basic information
vendor = db.StringField(required=True)
vendor_id = db.StringField(required=True)
brand = db.StringField(required=True)
main_category = db.StringField(required=True)
sub_category = db.StringField(required=True)
sex_tag = db.StringField(required=True, choices=SEX_TAG)
tags = db.ListField(db.StringField())
# descritpion
title = db.StringField(required=True)
title_en = db.StringField()
description = db.StringField(default='')
attributes = db.ListField(db.StringField())
# 如果有材质的话，以材质开头
information = db.ListField(db.StringField())
size_lookup = db.DictField(default={})
extra = db.DictField(default={})
status = db.StringField(default=ITEM_STATUS.NEW,
required=True,
choices=ITEM_STATUS)
availability = db.BooleanField(default=True, required=True)
# time
created_at = db.DateTimeField(default=datetime.utcnow, required=True)
modified = db.DateTimeField()
creator = db.StringField()
lookup_table = db.StringField()
size_chart = db.ListField(db.StringField())
fields_to_log = {
'url',
'original_price',
'price',
'discount',
'primary_img',
'vendor',
'brand',
'main_category',
'sub_category',
'sex_tag',
'tags',
'availability',
}
def __unicode__(self):
return '%s' % self.item_id
def __repr__(self):
return '%s' % self.item_id
@db.queryset_manager
def available_items(doc_cls, queryset):
return queryset.filter(availability=True)
@property
def specs(self):
return ItemSpec.objects(item_id=self.item_id)
@property
def available_specs(self):
return ItemSpec.objects(item_id=self.item_id, 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):
meta = item['meta']
specs = item.get('specs', [])
i = Item.objects(web_id=meta['web_id'])
if i:
item['meta']['status'] = ITEM_STATUS.MOD
return cls.modify(item)
# If category, brand and tags does not exisit then create.
Category.get_category_or_create(meta['main_category'], 1)
Category.get_category_or_create(meta['sub_category'], 2)
Brand.get_brand_or_create(meta['brand'])
Vendor.get_or_create(meta['vendor'])
for tag in meta['tags']:
Tag.get_tag_or_create(tag)
Statistics.create(meta['main_category'], meta['sub_category'],
meta['brand'], meta['tags'], meta['sex_tag'])
item = Item(**meta).save()
item_id = item.item_id
# Keep item specs clean. Remove accidentally left useless specs.
old_specs = ItemSpec.objects(item_id=item_id)
for spec in old_specs:
spec.delete()
for spec in specs:
spec['item_id'] = item_id
ItemSpec(**spec).save()
PriceHistory.upsert_price_history(item_id, meta['price'])
return item_id
@classmethod
def modify(cls, new_item, current_price=None):
# If the item does not exist in our db, then do not trust the coming
# mod data.
try:
old_item = Item.objects.get(web_id=new_item['meta']['web_id'])
except DoesNotExist:
current_app.logger.warning(
'crawler send item not exist in db: {}'.format(new_item))
return
# Old item is an mongoengine object.
# New item is a dictionary.
cls.update_item(old_item, new_item)
old_item.save()
if current_price:
PriceHistory.upsert_price_history(old_item.item_id, current_price)
return old_item.item_id
@classmethod
def update_item(cls, old_item, new_item):
meta = new_item['meta']
# If category, brand and tags does not exisit then create.
Category.get_category_or_create(meta['main_category'], 1)
Category.get_category_or_create(meta['sub_category'], 2)
Brand.get_brand_or_create(meta['brand'])
Vendor.get_or_create(meta['vendor'])
Statistics.create(meta['main_category'], meta['sub_category'],
meta['brand'], meta['tags'], meta['sex_tag'])
for k, v in meta.items():
setattr(old_item, k, v)
old_item.save()
@classmethod
def delete_item(cls, web_id):
try:
item = cls.objects.get(web_id=web_id)
item.status = 'DEL'
item.availability = False
item.save()
return item.item_id
except DoesNotExist:
pass
def to_simple_json(self):
return dict(id=str(self.item_id),
title=self.title,
price=getattr(self, 'price_details', lambda: '')(),
primary_image=self.primary_img,
status=self.status)
def price_details(self):
return dict(
price=self.price,
orig_price=self.original_price,
discount=ceil(
((self.original_price - self.price) / self.original_price) *
100),
)
class User(db.Document, UserMixin):
'''
The User class contains only basic and frequently used information
Superclass UserMixin can provide four authenticate methods required
by Flask-Login.
'''
meta = {
'db_alias': 'user_db',
}
name = db.StringField(required=True)
account = db.EmbeddedDocumentField('UserAccount')
information = db.EmbeddedDocumentField('UserInformation')
avatar_url = db.URLField(default='http://assets.maybi.cn/logo/panda.jpg')
# level
# 0: normal user
# 1: normal member; 2: advance member
# 3: premium member; 4: VIP member
level = db.IntField(default=0)
roles = db.ListField(db.StringField())
# whether subscribed our wechat account
subscribed_mp = db.BooleanField(default=False)
# favor related (item_ids)
num_favors = db.IntField(default=0, min_value=0)
favor_items = db.ListField(db.IntField())
addresses = db.ListField(db.ReferenceField('Address'))
default_address = db.ReferenceField('Address')
# favor related (post_ids)
num_post_likes = db.IntField(default=0, min_value=0)
like_posts = db.ListField(db.IntField())
is_deleted = db.BooleanField(default=False)
deleted_date = db.DateTimeField()
def __unicode__(self):
return '%s' % str(self.id)
#return u'{}'.format(self.name)
@property
def avatar_thumb(self):
return self.avatar_url[:23] + 'avatar_thumbs/80x80/' + self.avatar_url[
23:]
@db.queryset_manager
def active(doc_cls, queryset):
return queryset.filter(is_deleted=False)
@property
def is_admin(self):
return USER_ROLE.ADMIN in self.roles
def to_json(self):
data = dict(name=self.name,
avatar_url=self.avatar_url,
avatar_thumb=self.avatar_thumb,
num_followers=self.num_followers,
num_followings=self.num_followings,
created_at=str(self.account.created_at),
id=str(self.id))
return data
@classmethod
def authenticate(cls, email=None, password=None):
if email:
user = cls.active(account__email=email.lower()).first()
else:
user = None
if user:
authenticated = user.account.check_password(password)
else:
authenticated = False
return user, authenticated
def generate_auth_token(self, expires_in=604800):
s = Serializer(current_app.config['SECRET_KEY'], expires_in=expires_in)
return s.dumps({'id': str(self.id)}).decode('utf-8')
@staticmethod
def verify_auth_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return None
return User.objects(id=data['id']).first()
@classmethod
def create(cls, email, password, name, mobile_number=None):
# account
account = UserAccount(email=email.lower(),
mobile_number=mobile_number,
is_email_verified=True)
account.password = password
user = User(name=name,
roles=[USER_ROLE.MEMBER],
information=UserInformation(),
account=account)
user.save()
signals.user_signup.send('system', user=user)
return user
class SocialOAuth(db.Document):
meta = {'indexes': ['site', 'user', ('site_uid', 'site'), 'unionid']}
app = db.StringField(choices=['IOS', 'MOBILEWEB'], default='MOBILEWEB')
site = db.StringField(max_length=255, required=True)
site_uid = db.StringField(max_length=255,
required=True,
unique_with='site')
unionid = db.StringField()
user = db.ReferenceField('User')
site_uname = db.StringField(max_length=255)
access_token = db.StringField(required=True)
expire_date = db.DateTimeField()
refresh_token = db.StringField()
# wether we can get information of this oauth
can_refresh = db.BooleanField(default=True)
last_active_date = db.DateTimeField()
def to_json(self):
return dict(site=self.site, site_uname=self.site_uname)
@classmethod
def create(cls,
site,
site_uid,
site_uname,
access_token,
expires_in=0,
refresh_token=None,
email=None,
mobile_number=None,
gender=None,
password=None,
unionid=None,
app='MOBILEWEB',
is_email_verified=False):
""" create an oauth record and an user"""
oauth = cls(site=site,
site_uid=site_uid,
site_uname=site_uname,
access_token=access_token,
refresh_token=refresh_token,
unionid=unionid,
app=app)
if not email:
email = '{}-{}@maybi.cn'.format(
site,
hashlib.md5(
(app + site + site_uid).encode('utf-8')).hexdigest())
# create an user
user = User.create(email=email,
mobile_number=mobile_number,
password=password or site_uname,
name=site_uname)
user.account.is_email_verified = is_email_verified
user.information.gender = gender
if site == 'wechat':
user.subscribed_mp = True
user.save()
oauth.user = user
oauth.save()
oauth.update_token(access_token, expires_in)
return oauth
def update_token(self, access_token, expires_in=0):
expire_date = datetime.datetime.utcnow() + datetime.timedelta(
seconds=int(expires_in))
self.update(set__access_token=access_token,
set__expire_date=expire_date)
def re_auth(self,
access_token,
expires_in,
refresh_token=None,
unionid=None):
self.update_token(access_token, expires_in)
self.update(set__refresh_token=refresh_token)
if unionid:
self.update(set__unionid=unionid)
def update_avatar(self, url):
self.user.update(set__avatar_url=url)
@classmethod
def get_user(cls, site, site_uid):
so = cls.objects(site=site, site_uid=site_uid).first()
return so.user if so else None
@classmethod
def refresh_active(cls, site, site_uid, dt):
# ignore if document does not exist
cls.objects(site=site,
site_uid=site_uid).update_one(set__last_active_date=dt)
class User(db.Document, UserMixin, FavorAction):
'''
The User class contains only basic and frequently used information
Superclass UserMixin can provide four authenticate methods required
by Flask-Login.
'''
meta = {
'indexes': [
'name', 'account.created_at', 'roles', 'level', 'account.email',
'account.is_email_verified', 'is_deleted'
],
'ordering': ['-account.created_at']
}
name = db.StringField(required=True)
account = db.EmbeddedDocumentField('UserAccount')
information = db.EmbeddedDocumentField('UserInformation')
avatar_url = db.URLField(default='http://assets.maybi.cn/logo/panda.jpg')
# level
# 0: normal user
# 1: normal member; 2: advance member
# 3: premium member; 4: VIP member
level = db.IntField(default=0)
roles = db.ListField(db.StringField())
addresses = db.ListField(db.ReferenceField('Address'))
default_address = db.ReferenceField('Address')
# followers
num_followers = db.IntField(default=0, min_value=0)
num_followings = db.IntField(default=0, min_value=0)
followers = db.ListField(db.ReferenceField('User'))
followings = db.ListField(db.ReferenceField('User'))
# whether subscribed our wechat account
subscribed_mp = db.BooleanField(default=False)
# favor related (item_ids)
num_favors = db.IntField(default=0, min_value=0)
favor_items = db.ListField(db.IntField())
# favor related (post_ids)
num_post_likes = db.IntField(default=0, min_value=0)
like_posts = db.ListField(db.IntField())
# shopping cart
cart = db.ReferenceField('Cart')
# wallet
wallet = db.ReferenceField('CouponWallet')
is_deleted = db.BooleanField(default=False)
deleted_date = db.DateTimeField()
def __unicode__(self):
return '%s' % str(self.id)
#return u'{}'.format(self.name)
@property
def coin_wallet(self):
import application.models as Models
return Models.CoinWallet.get_or_create(user=self)
@property
def hongbao_wallet(self):
import application.models as Models
return Models.HongbaoWallet.by_user(user=self)
@property
def orders(self):
import application.models as Models
return Models.Order.objects(customer_id=self.id, is_paid=True)
@property
def avatar_thumb(self):
return self.avatar_url[:23] + 'avatar_thumbs/80x80/' + self.avatar_url[
23:]
def used_coupon(self, code):
import application.models as Models
return bool(
Models.Order.objects(customer_id=self.id,
is_paid=True,
coupon__codes__contains=code))
@db.queryset_manager
def active(doc_cls, queryset):
return queryset.filter(is_deleted=False)
@property
def is_admin(self):
return USER_ROLE.ADMIN in self.roles
# Follow / Following
def follow(self, other):
if self not in other.followers:
other.followers.append(self)
other.num_followers += 1
if other not in self.followings:
self.followings.append(other)
self.num_followings += 1
self.save()
other.save()
signals.site_message.send(self,
dest=other.id,
source=self,
imgs=[self.avatar_url],
noti_type=NOTI_TYPE.FOLLOW,
title='')
def unfollow(self, other):
if self in other.followers:
other.followers.remove(self)
other.num_followers -= 1
if other in self.followings:
self.followings.remove(other)
self.num_followings -= 1
self.save()
other.save()
def is_following(self, other):
return other in self.followings
def to_json(self):
data = dict(name=self.name,
avatar_url=self.avatar_url,
avatar_thumb=self.avatar_thumb,
num_followers=self.num_followers,
num_followings=self.num_followings,
created_at=str(self.account.created_at),
id=str(self.id))
return data
@classmethod
def authenticate(cls, email=None, password=None):
if email:
user = cls.active(account__email=email.lower()).first()
else:
user = None
if user:
authenticated = user.account.check_password(password)
else:
authenticated = False
return user, authenticated
def generate_auth_token(self, expires_in=604800):
s = Serializer(current_app.config['SECRET_KEY'], expires_in=expires_in)
return s.dumps({'id': str(self.id)}).decode('utf-8')
@staticmethod
def verify_auth_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return None
return User.objects(id=data['id']).first()
@classmethod
def create(cls, email, password, name, mobile_number=None):
from application.models.coupon.wallet import CouponWallet
from application.models.cart import Cart
# init user account.
cart = Cart()
cart.save()
wallet = CouponWallet()
wallet.save()
# account
account = UserAccount(email=email.lower(),
mobile_number=mobile_number,
is_email_verified=True)
account.password = password
user = User(name=name,
roles=[USER_ROLE.MEMBER],
information=UserInformation(),
cart=cart,
wallet=wallet,
account=account)
user.save()
signals.user_signup.send('system', user=user)
return user
def mark_deleted(self):
if self.is_deleted:
return
# delete social oauth, otherwise user can still login via wechat
SocialOAuth.objects(user=self).delete()
self.is_deleted = True
self.deleted_date = datetime.datetime.utcnow()
self.save()
