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 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 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 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 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 Category(db.Document):
meta = {
'db_alias': 'inventory_db'
}
en = db.StringField(required=True, unique=True)
cn = db.StringField()
level = db.IntField(required=True)
logo = db.StringField()
def __unicode__(self):
return '%s' % self.en
@classmethod
def get_category_or_create(cls, sub, lv):
category = cls.objects(en=sub, level=lv).first()
if not category:
category = cls(en=sub, level=lv).save()
return category
@classmethod
def update_cn(cls, en, cn):
cls.objects(en=en).update(set__cn=cn)
def to_json(self):
return dict(
en=self.en,
cn=self.cn,
level=self.level,
logo=self.logo)
class GuestRecord(db.Document, FavorAction):
'''
Visit records for guests user
'''
meta = {'indexes': ['session_key']}
session_key = db.StringField(required=True)
device_tokens = db.ListField(db.StringField())
# favor related (item_ids)
num_favors = db.IntField(default=0, min_value=0)
favor_items = db.ListField(db.IntField())
@classmethod
def by_key(cls, key):
cls.objects(session_key=key).update_one(set__session_key=key,
upsert=True)
return cls.objects.get(session_key=key)
class Role(db.Document):
name = db.StringField(unique=True)
permission = db.IntField()
def __repr__(self):
return '{}-{}'.format(self.name, self.permission)
__str__ = __repr__
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 Role(db.Document):
name = db.StringField()
permission = db.IntField()
def __repr__(self):
return "{}-{}".format(self.name, self.permission)
def __str__(self):
return self.__repr__()
def __unicode__(self):
return self.__repr__()
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 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 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 OrderStat(db.Document):
meta = {'db_alias': 'order_db', 'indexes': ['user_id']}
user_id = db.ObjectIdField(required=True)
orders = db.ListField(db.ReferenceField('Order'))
items = db.ListField(db.IntField())
total = db.FloatField(default=0)
received = db.FloatField(default=0)
num_orders = db.IntField(default=0)
num_unpaid = db.IntField(default=0)
num_waiting = db.IntField(default=0)
def clean(self):
for field in ('total', 'received', 'num_orders', 'num_unpaid',
'num_waiting'):
if getattr(self, field, 0) < 0:
setattr(self, field, 0)
@classmethod
def by_user(cls, user_id):
cls.objects(user_id=user_id).update_one(set__user_id=user_id,
upsert=True)
return cls.objects(user_id=user_id).first()
class PriceHistory(db.Document):
meta = {
'db_alias': 'inventory_db',
}
item_id = db.IntField()
history = db.EmbeddedDocumentListField('Price')
@classmethod
def upsert_price_history(cls, item_id, cur):
if not cls.objects(item_id=item_id):
price = Price(price=cur)
cls(item_id=item_id, history=[price]).save()
else:
if cls.objects(item_id=item_id).first().history[-1].price != cur:
price = Price(price=cur)
cls.objects(item_id=item_id).update_one(push__history=price)
class Statistics(db.Document):
meta = {
'db_alias': 'inventory_db',
'indexes': ['tag', 'sub_category', 'main_category', 'brand'],
}
main_category = db.StringField()
sub_category = db.StringField()
brand = db.StringField()
tag = db.StringField()
sex_tag = db.StringField()
count = db.IntField(required=True, default=1)
@classmethod
def create(cls, main, sub, brand, tags, sex_tag):
if not tags:
tags = [None]
for tag in tags:
try:
stats = cls.objects.get(main_category=main,
sub_category=sub,
brand=brand,
tag=tag,
sex_tag=sex_tag)
stats.count += 1
stats.save()
except:
stats = cls(main_category=main,
sub_category=sub,
brand=brand,
tag=tag,
sex_tag=sex_tag)
stats.save()
def to_json(self):
return dict(main=self.main_category,
sub=self.sub_category,
brand=self.brand,
tag=self.tag,
sex_tag=self.sex_tag,
count=self.count)
class ConsumableCoupon(db.EmbeddedDocument):
'''
ConsumableCoupon is stored in user's wallet and consumable.
'''
code = db.StringField(required=True)
number = db.IntField(default=1)
@property
def coupon(self):
return Coupon.objects(code=self.code).first()
@property
def is_expired(self):
return self.coupon.is_expired
def to_json(self):
if not self.coupon:
return None
res = self.coupon.to_json()
res['number'] = self.number
res['display_code'] = res['code']
return res
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 CouponWallet(db.Document):
meta = {
'indexes': ['consumable_coupons.code']
}
consumable_coupons = db.EmbeddedDocumentListField('ConsumableCoupon')
coupons = db.ListField(db.StringField())
coins = db.IntField(required=True, default=0)
def add_consumable_coupon(self, code, number):
coupon = Coupon.objects(
code=code, apply=COUPON_APPLY.BY_DISPLAY_ID).first()
if not coupon:
return
c = ConsumableCoupon(code=code, number=number)
self.update(push__consumable_coupons=c)
Signals.coupon_received.send(self, wallet=self, coupon=coupon)
return coupon
def get_consumable_coupon(self, code):
try:
coupon = self.consumable_coupons.get(code=code)
return coupon
except:
return None
def has_consumable_coupon(self, code):
c = self.get_consumable_coupon(code)
if c and not c.is_expired:
return True
return False
def has_coupon(self, coupon):
for c in self.consumable_coupons:
if c.code == coupon.code and not c.is_expired:
return True
return False
def use_consumable_coupon(self, code):
if not code:
return
try:
coupon = self.consumable_coupons.get(code=code)
except:
return
if coupon.is_expired:
return
if coupon.number > 1:
coupon.number -= 1
else:
self.consumable_coupons.remove(coupon)
self.save()
def clear_expired_coupons(self):
for c in self.consumable_coupons:
if datetime.utcnow() >= (
c.coupon.expire_date + timedelta(days=31)):
self.consumable_coupons.remove(c)
self.save()
def to_json(self):
cc = [c.to_json() for c in self.consumable_coupons]
return dict(consumable_coupons=cc,
coupons=self.coupons)
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 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 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 Role(db.Document):
name = db.StringField(unique=True)
permission = db.IntField()
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 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()
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)
