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)