class EntrySpec(db.Document): meta = { 'db_alias': 'cart_db', 'indexes': ['sku', 'item_id', ] } sku = db.IntField(required=True, unique=True) item_id = db.IntField() title = db.StringField() primary_image = db.StringField() item_available = db.BooleanField() price = db.FloatField() available = db.BooleanField() attributes = db.DictField() images = db.ListField(db.StringField()) attribute_list = db.ListField(db.StringField()) attribute_desc = db.DictField() brand = db.DictField() last_update_date = db.DateTimeField() carts = db.ListField(db.ReferenceField('Cart')) last_empty_date = db.DateTimeField()
class ChannelProvider(db.Document): meta = {'db_alias': 'order_db'} name = db.StringField() display_name = db.StringField() description = db.StringField() service_intro = db.DictField() country = db.StringField() is_active = db.BooleanField(default=False) shipping = db.FloatField(required=True) is_recommended = db.BooleanField(default=False) def __repr__(self): return '<ChannelProvider {}>'.format(self.name) @classmethod def get_shipping(cls, channel_name, country): if not channel_name: channel_name = 'default' provider = cls.objects(name=channel_name, country=country).first() return provider.shipping @queryset_manager def active(doc_cls, queryset): return queryset.filter(is_active=True) def to_json(self): return dict(name=self.name, display_name=self.display_name, service_intro=self.service_intro, desc=self.description)
class Coupon(db.Document): meta = { 'strict': False, 'db_alias': 'order_db', 'indexes': ['code', 'apply', 'expire_date', 'description'] } scope = db.StringField(required=True, choices=COUPON_SCOPE, default=COUPON_SCOPE.ORDER) coupon_type = db.StringField(default=COUPON_TYPES.NORMAL, required=True, choices=COUPON_TYPES) value = db.FloatField() description = db.StringField() effective_date = db.DateTimeField(default=datetime.utcnow) expire_date = db.DateTimeField(default=datetime(2019, 12, 31)) code = db.StringField(unique=True) # by which means this coupon can be applied: by coupon code, by display_id apply = db.StringField(required=True, default=COUPON_APPLY.BY_DISPLAY_ID, choices=COUPON_APPLY) required_amount = db.FloatField(default=0) required_final = db.FloatField(default=0) require_new_order = db.BooleanField(default=False) once_per_user = db.BooleanField(default=False) # note for internal usage note = db.StringField() coupon_category = db.StringField(choices=['PROMOTION', 'STAFF', 'NEW_USER'], default='PROMOTION') @property def is_expired(self): if not self.expire_date: return False return (datetime.utcnow() >= self.expire_date) def to_json(self): return dict( coupon_type=self.coupon_type, value=self.value, code=self.code, effective_date=format_date(self.effective_date, '%Y-%m-%d'), expire_date=format_date(self.expire_date, '%Y-%m-%d'), is_expired=self.is_expired, description=self.description) def is_effective(self): return self.effective_date <= datetime.utcnow() < self.expire_date def can_apply(self, order): res = bool( (self.required_final <= order.final) and (self.required_amount <= order.amount) and not (self.require_new_order and order.customer.orders) and not (self.once_per_user and order.customer.used_coupon(self.code)) ) return res
class LogisticProvider(db.Document, WeightPrice): meta = { 'db_alias': 'order_db' } name = db.StringField() display_name = db.StringField() description = db.StringField() service_intro = db.DictField() logo = db.StringField() country = db.StringField() is_active = db.BooleanField(default=False) rule_desc = db.StringField() init_price = db.FloatField(required=True) init_weight = db.IntField(required=True) continued_price = db.FloatField(required=True) continued_weight = db.IntField(required=True) init_coin = db.IntField(default=0) features = db.ListField(db.StringField()) promotion = db.StringField(default='') limited_weight = db.IntField(required=True) limited_category = db.ListField(db.StringField()) is_recommended = db.BooleanField(default=False) rating = db.DecimalField(precision=1) rating_users = db.IntField() def __repr__(self): return '<LogisticProvider {}>'.format(self.name) # TODO: memoize here @classmethod def get_provider_shipping(cls, logistic_name, country, weight): if not logistic_name: logistic_name = 'default' provider = cls.objects(name=logistic_name, country=country).first() return provider.get_shipping(weight) @queryset_manager def active(doc_cls, queryset): return queryset.filter(is_active=True) def to_json(self): return dict( name = self.name, display_name = self.display_name, service_intro = self.service_intro, desc = self.description)
class UserAccount(db.EmbeddedDocument): ''' The UserAccount class contains user personal informations and account settings ''' created_at = db.DateTimeField(default=datetime.datetime.utcnow, required=True) # login related email = db.EmailField(required=True, unique=True) mobile_number = db.StringField() is_email_verified = db.BooleanField(default=False) _password = db.StringField(max_length=255) activation_key = db.StringField(max_length=255) activate_key_expire_date = db.DateTimeField() # =============================================== # password @property def password(self): return self._password @password.setter def password(self, password): self._password = bcrypt.generate_password_hash(password).decode( 'utf-8') print(self._password) def check_password(self, password): if self.password is None: return False return bcrypt.check_password_hash(self.password, password) def to_json(self): return dict(created_at=str(self.created_at), email=self.email)
class Item(db.Document): content = db.StringField(required=True) created_date = db.DateTimeField() completed = db.BooleanField(default=False) completed_date = db.DateTimeField() created_by = db.ReferenceField('User', required=True) notes = db.ListField(db.StringField()) priority = db.IntField() def __repr__(self): return "<Item: {} Content: {}>".format(str(self.id), self.content) def to_json(self): return { 'id': str(self.id), 'content': self.content, 'completed': self.completed, 'completed_at': self.completed_date.strftime("%Y-%m-%d %H:%M:%S") if self.completed else "", 'created_by': self.created_by.name, 'notes': self.notes, 'priority': self.priority }
class Todo(db.Document): desc = db.StringField() create_at = db.DateTimeField(default=datetime.now()) finished_at = db.DateTimeField(default=None) # todo的完成时间 is_finished = db.BooleanField(default=False) # todo状态:1. finished, 2. open creator = db.ReferenceField('User') todolist = db.ReferenceField('TodoList') @property def id(self): return str(self._id) @property def status(self): return 'finished' if self.is_finished else 'open' def finished(self): self.finished_at = datetime.now() self.is_finished = True self.save() def reopen(self): self.finished_at = None self.is_finished = False self.save() def to_dict(self): return { 'description': self.desc, 'creator': self.creator.username, 'create_at': self.create_at, 'finished_at': self.finished_at, 'status': self.status }
class Data(db.Document): meta = { 'db_alias': 'data_db', } sku = db.IntField(required=True, unique=True) item_id = db.IntField() title = db.StringField() primary_image = db.StringField() item_available = db.BooleanField()
class ItemSpec(db.Document): meta = { 'db_alias': 'inventory_db', 'indexes': [ 'item_id', 'web_sku', 'sku', 'price', 'original_price', 'availability', 'attributes', 'created_at', 'stock' ], 'ordering': ['price'] } item_id = db.IntField(required=True) sku = db.SequenceField(required=True, unique=True, primary_key=True) web_sku = db.StringField(required=True) images = db.ListField(db.StringField(required=True)) original_price = db.FloatField(required=True, min_value=0) price = db.FloatField(required=True, min_value=0) china_price = db.FloatField(min_value=0, default=0) availability = db.BooleanField(default=True, required=True) stock = db.IntField(default=-1) # spec.attributes: {color: 'Blue', size: 'M'} attributes = db.DictField() shipping_info = db.DictField() created_at = db.DateTimeField(default=datetime.utcnow, required=True) modified = db.DateTimeField() url = db.StringField() extra = db.DictField(default={}) @property def item(self): return Item.objects(item_id=self.item_id).first() def __unicode__(self): return '%s' % self.sku def update_spec(self, new_spec): for k, v in new_spec.items(): setattr(self, k, v) self.save()
class Banner(db.Document): meta = {'db_alias': 'content_db', 'indexes': ['published']} created_at = db.DateTimeField(default=datetime.datetime.utcnow, required=True) banner_type = db.StringField(default="BOARD", choices=['BOARD', 'URL']) target = db.StringField() img = db.StringField() date_from = db.DateTimeField(default=datetime.datetime.today()) date_until = db.DateTimeField(default=datetime.datetime(2029, 12, 30)) published = db.BooleanField(default=True) order = db.SequenceField() def __repr__(self): return '<Banner object: {}>'.format(str(self.id)) @classmethod def get_latest(cls, n=10): now = datetime.datetime.now() docs = cls.objects(date_from__lte=now, date_until__gt=now).order_by( '-order', '-created_at').limit(n) return docs @property def target_obj(self): import application.models as Models if self.banner_type == 'BOARD': # if BOARD, return title return Models.Board.objects(id=self.target).first() return self.target def to_json(self): return { 'type': self.banner_type, 'target': self.target, 'img': self.img, 'created_at': format_date(self.created_at), }
class Trade(db.Document): meta = { 'indexes': ['wallet', 'user', 'time', 'kind', 'reason_id', 'reason'], 'ordering': ['wallet'], 'allow_inheritance': True, } user = db.ReferenceField('User') wallet = db.ReferenceField(CoinWallet) amount = db.IntField(required=True) coin_type = db.StringField(choices=COIN_TYPE, default=COIN_TYPE.COIN) time = db.DateTimeField(required=True) kind = db.StringField(required=True, choices=tuple(COIN_TRADE_TYPE)) reason = db.StringField(required=True, choices=tuple(COIN_TRADE_REASON)) reason_id = db.StringField() description = db.StringField() is_hold = db.BooleanField() descs = { 'PAY': u'购买', 'CANCEL': u'取消订单', 'SHIPPING_FEE': u'返还运费', 'PROMOTE': u'参与活动', 'WECHAT_LOGIN': u'微信账号登陆', 'IOS_APP': u'下载手机客户端', 'VERIFIED_ID': u'上传身份证资料', 'SHARED': u'分享了一个链接', 'SECOND_SHARED': u'你的链接被分享了', 'SHARED_ORDER': u'通过你的链接购买', 'ORDER': u'订单完成', 'OTHER': u'其他', } def clean(self): if not self.description: self.description = self.descs.get(self.reason, '')
class Post(db.Document): meta = { 'db_alias': 'content_db', 'indexes': [ 'post_id', 'user_id', 'title', 'post_type', 'location', 'tags', 'num_views', 'created_at' ], 'ordering': ['-created_at'] } post_id = db.SequenceField(required=True, unique=True, primary_key=True) # id primary_image = db.StringField() images = db.ListField(db.StringField()) tags = db.ListField(db.StringField()) title = db.StringField(default='') location = db.PointField() location_extra = db.DictField() post_type = db.StringField(default=POST_TAG_TYPES.SHOW, choices=POST_TAG_TYPES) # extra num_likes = db.IntField(default=0) num_comments = db.IntField(default=0) num_views = db.IntField(default=0) status = db.StringField(default=POST_STATUS.NEW, required=True, choices=POST_STATUS) approved = db.BooleanField(default=True, required=True) # time created_at = db.DateTimeField(default=datetime.utcnow, required=True) modified = db.DateTimeField() user_id = db.ObjectIdField() def __unicode__(self): return '%s' % self.post_id def __repr__(self): return '%s' % self.post_id @db.queryset_manager def approved_posts(doc_cls, queryset): return queryset.filter(approved=True) @classmethod def create(cls, post): for tag in post['tags']: PostTag.get_tag_or_create(tag) post = Post(**post) post.approved = False post.save() post_id = post.post_id return post_id @classmethod def modify(cls, new_post): # If the post does not exist in our db, then do not trust the coming # mod data. try: old_post = Post.objects.get(post_id=new_post['post_id']) old_post.status = POST_STATUS.MOD except DoesNotExist: current_app.logger.warning( 'does not exist in db: {}'.format(new_post)) return for k, v in new_post.items(): setattr(old_post, k, v) old_post.save() return old_post.post_id @classmethod def delete_post(cls, post_id): try: post = cls.objects.get(id=post_id) post.status = 'DEL' post.approved = False post.save() return post.post_id except DoesNotExist: pass @property def small_thumbnail(self): return self.primary_image[: 23] + 'post_thumbs/180x180/' + self.primary_image[ 23:] @property def large_thumbnail(self): return self.primary_image[: 23] + 'post_thumbs/480x480/' + self.primary_image[ 23:] @property def user(self): from application import models as Models return Models.User.objects(id=self.user_id).first() def to_simple_json(self): type_map = { "SHOW": u"心情", "SERVICE": u"服务", "TRADE": u"买卖", } type_dt = {'en': self.post_type, 'cn': type_map[self.post_type]} return dict(post_id=str(self.post_id), title=self.title, type=type_dt, primary_image=self.primary_image, large_url=self.large_thumbnail, small_url=self.small_thumbnail, images=self.images, created_at=self.created_at.strftime("%Y-%m-%dT%H:%M:%S Z"), num_likes=self.num_likes, num_comments=self.num_comments, num_views=self.num_views, tags=self.tags, status=self.status)
class Logistic(db.Document): meta = { 'db_alias': 'order_db', 'indexes': ['is_closed', '-created_at', 'order', 'entries', 'detail.status', 'detail.channel', 'detail.modified', 'detail.cn_tracking_no', 'detail.cn_logistic_name', 'detail.payment_received_date', 'detail.processing_date', 'detail.shipping_date', 'detail.port_arrived_date', 'detail.received_date', 'detail.partner', 'detail.partner_tracking_no', ('detail.status', '-created_at'), ] } order = db.ReferenceField('Order', required=True) entries = db.ListField(db.ReferenceField('OrderEntry')) returned_entries = db.ListField(db.ReferenceField('OrderEntry')) is_closed = db.BooleanField(default=False, required=True) close_reason = db.StringField() closed_at = db.DateTimeField() created_at = db.DateTimeField( required=True, default=datetime.datetime.utcnow ) detail = db.EmbeddedDocumentField('LogisticDetail') def __unicode__(self): return '%s' % str(self.id) @property def estimated_weight(self): return sum(float(entry.item_snapshot.weight) * entry.quantity for entry in self.entries) def to_json(self): detail = self.detail return dict(cn_tracking_no=detail.cn_tracking_no, cn_logistic_name=detail.cn_logistic_name, partner_tracking_no=detail.partner_tracking_no, partner_name=detail.partner.name if detail.partner else '', payment_received_date=get_date(detail, 'payment_received_date'), processing_date=get_date(detail, 'processing_date'), shipping_date=get_date(detail, 'shipping_date'), port_arrived_date=get_date(detail, 'port_arrived_date'), received_date=get_date(detail, 'received_date'), estimated_weight=self.estimated_weight, real_weight=detail.real_weight, status=detail.status) @property def amount(self): return sum(entry.amount for entry in self.entries) @property def amount_usd(self): return sum(entry.amount_usd for entry in self.entries) @classmethod def create(cls, order): from application.models.order.partner import Partner def update_order(o): o.logistics.append(log) o.save() o.update_logistic_status() def create_logistic(order): log = cls(detail=LogisticDetail()) log.order = order log.entries = order.entries log.detail.partner = Partner.objects().first() log.detail.partner_tracking_no = gen_uid() log.detail.status = order.status date_field = log.detail.attr_by_log_stat[order.status] setattr(log.detail, date_field, datetime.datetime.utcnow()) log.save() return log log = create_logistic(order) update_order(order) return log @classmethod def merge_with(cls, los): if not type(los) is list: return False start = 0 for index in range(len(los)-1): if los[index+1].detail.cn_tracking_no != \ los[start].detail.cn_tracking_no or \ los[index+1].order != los[0].order : return False for index in range(len(los)-1): map(lambda e: los[index+1].entries.append(e), los[index].entries) los[index].entries = [] los[index].save() los[index].close( 'merged with %s' % los[index+1].id, datetime.datetime.utcnow() ) los[index+1].save() if index+1 == len(los)-1: comment = LogisticRemark( content=u"合并单", creator=current_user.name ) los[index+1].detail.remarks.append(comment) los[index+1].save() return los[index+1] def close(self, reason, time=None): self.is_closed = True self.close_reason = reason self.closed_at = time or datetime.datetime.utcnow() self.save() order = self.order if self in order.logistics: order.logistics.remove(self) order.closed_logistics.append(self) order.save() def fork_by_entries(self, entry_ids): def get_entry(entries, eid): for e in entries: if str(eid) == str(e.id): return e return False if not type(entry_ids) is list: return False if len(self.entries) < 2: return False if self.detail.status != 'PAYMENT_RECEIVED': self.detail.status = 'PROCESSING' self.detail.processing_date = datetime.datetime.utcnow() self.save() forked_order = Logistic(detail=self.detail) entries = [get_entry(self.entries, e) for e in entry_ids] if not entries: False forked_order.entries = entries forked_order.order = self.order forked_order.save() self.order.logistics.append(forked_order) self.order.save() map(lambda e: self.entries.remove(e), entries) self.save() old_ptn = self.detail.partner_tracking_no new_ptn = gen_uid() forked_order.detail.partner_tracking_no = new_ptn remark = u"%s拆出了%s" % (old_ptn, new_ptn) forked_order.update_remark(remark, current_user.name) self.update_remark(remark, current_user.name) return self, forked_order def update_status(self, new_status): try: index = LOG_STATS.index(new_status) except ValueError: return log = self.detail old_status = log.status if index > LOG_STATS.index(old_status): log.status = new_status now = datetime.datetime.utcnow() date_field = log.attr_by_log_stat[new_status] if not getattr(log, date_field): setattr(log, date_field, now) self.save() self.order.update_logistic_status() def update_logistic(self, info): log = self.detail next_status = info.get('status', '') require = { 'SHIPPING': ['cn_tracking_no', 'cn_logistic_name'], } if next_status in require.keys(): values = require[next_status] for value in values: if value in info: continue value = getattr(self.detail, value) if value in [None, '', 'None', '?', u'?', u'None', 'Undefined', u'Undefined']: raise Exception("Fail to update logistic") if current_user and not current_user.is_anonymous: modified_by = current_user.name else: modified_by = 'system' self.update_status(next_status) remark = info.get('remark', None) if remark: self.update_remark(remark, modified_by) delay_content = info.get('delay', None) if delay_content: self.update_delay(delay_content, modified_by) irregularity = info.get('irregularity', None) if irregularity: self.update_irregularity(irregularity, modified_by) for field, value in info.items(): if field in ['status']: continue setattr(log, field, value) self.save() Signals.logistic_stat_changed.send( 'send to logistic partner', lo=self, status=next_status) Signals.logistic_info_updated.send('system', logistic=self) def update_remark(self, content, modified_by): remark = LogisticRemark(content=content, creator=modified_by) self.detail.remarks.append(remark) self.save() def update_delay(self, content, modified_by): delays = self.detail.delay_details.filter(status=self.detail.status) if delays: delays.update(reason=content, creator=modified_by) else: delay = LogisticDelay( reason=content, creator=modified_by, status=self.detail.status ) self.detail.delay_details.append(delay) remark = LogisticRemark(content=content, creator=modified_by) self.detail.remarks.append(remark) self.save() def update_irregularity(self, irregularity, modified_by): irregularity.creator = modified_by self.detail.irregular_details.append(irregularity) self.save() @property def shipping_history(self): res = [] status = self.detail.status for st in LOG_STATS: field = self.detail.attr_by_log_stat[st] val = getattr(self.detail, field) if not val: continue res.append({'time': format_date(val), 'desc': SHIPPING_HISTORY[st], 'status': st}) if st == status: break return res @property def express_tracking(self): import application.models as Models com = self.detail.cn_logistic_name nu = self.detail.cn_tracking_no if com and nu: tracking = Models.ExpressTracking.find( company=com, number=nu) return tracking return None @classmethod def pre_save_post_validation(cls, sender, document, **kwargs): if not kwargs['created']: old_log = cls.objects(id=document.id).first().detail new_log = document.detail for field in LogisticDetail._fields: if field == 'modified': continue if (getattr(old_log, field) != getattr(new_log, field)): new_log.modified = datetime.datetime.utcnow() if current_user and not current_user.is_anonymous: new_log.modified_by = current_user.name else: new_log.modified_by = 'system' return else: document.detail.modified = datetime.datetime.utcnow()
class LogisticDelay(db.EmbeddedDocument): reason = db.StringField() is_done = db.BooleanField(default=False) status = db.StringField(choices=LOG_STATS) creator = db.StringField() created_at = db.DateTimeField(default=datetime.datetime.utcnow)
class Item(db.Document): meta = {'db_alias': 'inventory_db'} owner = db.StringField() owner_id = db.StringField() item_id = db.StringField(primary_key=True) # id eth_token = db.StringField() ## price price = db.FloatField() primary_img = db.StringField() images = db.ListField(db.StringField()) # basic information title = db.StringField() brand = db.StringField() condition = db.StringField() description = db.StringField(default='') madein = db.StringField() #color = db.ListField(db.StringField()) location = db.StringField() main_category = db.StringField() sub_category = db.StringField() sex_tag = db.StringField() tags = db.ListField(db.StringField()) availability = db.BooleanField(default=True) state = db.StringField() # time created_at = db.DateTimeField(default=datetime.utcnow) modified = db.DateTimeField() creator = db.StringField() def __unicode__(self): return '%s' % self.item_id def __repr__(self): return '%s' % self.item_id @property def cart_fields(self): return ['item_id', 'title', 'primary_img', 'price'] def to_cart(self): result = {f: getattr(self, f) for f in self.cart_fields} return result @db.queryset_manager def available_items(doc_cls, queryset): return queryset.filter(availability=True) @property def small_thumbnail(self): return self.primary_img[:23] + 'thumbnails/150x150/' + self.primary_img[ 23:] @property def large_thumbnail(self): return self.primary_img[:23] + 'thumbnails/400x400/' + self.primary_img[ 23:] @classmethod def create(cls, item): item = Item(**item).save() item_id = item.item_id return item_id
class Order(db.Document): meta = { 'db_alias': 'order_db', 'ordering': ['-created_at'], 'indexes': [ 'customer_id', 'short_id', 'created_at', 'status', 'address', 'amount', 'final', 'order_type', 'is_paid', 'is_payment_abnormal', 'refund_entries' ] } created_at = db.DateTimeField(default=datetime.datetime.utcnow, required=True) order_type = db.StringField(choices=ORDER_TYPE, default=ORDER_TYPE.COMMODITY) expired_in = db.IntField(default=1440) # in minutes payment_expired_in = db.IntField( default=1440) # minutes before payment should expire short_id = db.SequenceField(required=True, unique=True) is_vip = db.BooleanField(default=False) status = db.StringField(max_length=255, required=True, choices=ORDER_STATUS, default=ORDER_STATUS.PAYMENT_PENDING) status_modified = db.DateTimeField() source = db.StringField(choices=ORDER_SOURCES) is_rewards_given = db.BooleanField(default=False) # order detail amount_usd = db.FloatField(default=0) amount = db.FloatField(default=0) discount = db.ListField(db.DictField()) # only for coupon coupon_codes = db.ListField(db.StringField()) coin = db.IntField() hongbao = db.IntField() cash = db.IntField() final = db.FloatField(required=True) logistic_provider = db.StringField() estimated_tax = db.FloatField(default=0) real_tax = db.FloatField(default=-1) paid_tax = db.FloatField(default=-1) # for internal usage forex = db.FloatField() real_shipping = db.FloatField() # real shipping fee paid cn_shipping = db.FloatField(default=0) address = db.ReferenceField('Address') customer_id = db.ObjectIdField(required=True) is_new_customer = db.BooleanField(default=False) entries = db.ListField( db.ReferenceField('OrderEntry', reverse_delete_rule=mongoengine.PULL)) extra = db.StringField() # keep old property it here for migration logistics = db.ListField(db.ReferenceField('Logistic')) closed_logistics = db.ListField(db.ReferenceField('Logistic')) # this doesn't indicate whether customer have paid tax or not is_paid = db.BooleanField(default=False) is_payment_abnormal = db.BooleanField(default=False) paid_date = db.DateTimeField() pay_tax_deadline = db.DateTimeField() # informations of refundation refund_entries = db.ListField( db.ReferenceField('OrderEntry', reverse_delete_rule=mongoengine.PULL)) refund_amount = db.FloatField(default=0) is_test = db.BooleanField(default=False) fields_to_log = { 'status', 'amount', 'coin', 'final', 'estimated_tax', 'real_tax', 'paid_tax', 'real_shipping', 'is_paid', } PROCESSING_STATUS = [ORDER_STATUS.PAYMENT_RECEIVED, ORDER_STATUS.SHIPPING] ABNORMAL_STATUS = [ ORDER_STATUS.CANCELLED, ORDER_STATUS.ABNORMAL, ORDER_STATUS.ORDER_DELETED, ORDER_STATUS.EXPIRED, ORDER_STATUS.REFUNDED ] def __unicode__(self): return '%s' % self.sid @classmethod def get_order_or_404(cls, order_id, check_user=True): try: order = cls.objects(id=order_id).first_or_404() except mongoengine.ValidationError: try: short_id = int(order_id) except (ValueError, TypeError): abort(404) order = cls.objects(short_id=short_id).first_or_404() if check_user and str(order.customer_id) != str(current_user.id): abort(404) return order @queryset_manager def commodities(doc_cls, queryset): return queryset.filter(order_type=ORDER_TYPE.COMMODITY, status__nin=doc_cls.ABNORMAL_STATUS) @queryset_manager def transfer(doc_cls, queryset): return queryset.filter(order_type=ORDER_TYPE.TRANSFER, status__nin=doc_cls.ABNORMAL_STATUS) @queryset_manager def processing(doc_cls, queryset): return queryset.filter(status__in=doc_cls.PROCESSING_STATUS) @queryset_manager def payment_pending(doc_cls, queryset): return queryset.filter(status=ORDER_STATUS.PAYMENT_PENDING) @queryset_manager def abnormal(doc_cls, queryset): ''' Define abnormal: status is abnormal, or partial entries are refunded.''' return queryset.filter( Q(status__in=doc_cls.ABNORMAL_STATUS) | \ (Q(refund_entries__0__exists=True) & Q(status__in=(doc_cls.PROCESSING_STATUS+[ORDER_STATUS.RECEIVED]))) ) @queryset_manager def received(doc_cls, queryset): return queryset.filter(status=ORDER_STATUS.RECEIVED) def is_processing(self): return self.status in self.PROCESSING_STATUS def is_payment_pending(self): return self.status == ORDER_STATUS.PAYMENT_PENDING def is_abnormal(self): if self.status in self.ABNORMAL_STATUS: return True if self.status in self.PROCESSING_STATUS or self.status == ORDER_STATUS.RECEIVED: return len(self.refund_entries) > 0 return False def has_refund_entries(self): if self.status in (self.PROCESSING_STATUS + [ORDER_STATUS.RECEIVED, ORDER_STATUS.REFUNDED]): return len(self.refund_entries) > 0 return False @property def tax(self): if self.real_tax == -1: return self.estimated_tax else: return self.real_tax @property def shipping(self): return self.cn_shipping @property def estimated_weight(self): return sum( float(entry.item_snapshot.weight) * entry.quantity for entry in self.entries) @property def pay_tax_remain_days(self): if self.pay_tax_deadline: time_remain = self.pay_tax_deadline.date() - datetime.date.today() if time_remain.days > 0: return time_remain.days @property def latest_logistic(self): from application.models import LogisticDetail attr = LogisticDetail.attr_by_log_stat.get(self.status) if not attr: return None return max(self.logistics, key=lambda l: getattr(l.detail, attr)) @classmethod def create_transfer(cls, customer_id, entries, logistic_provider, coupon_codes, coin=0, cash=0, address=None, **kwargs): from application.models import ForexRate order = cls(customer_id=customer_id, entries=entries, logistic_provider=logistic_provider, coupon_codes=coupon_codes, coin=coin, cash=cash, **kwargs) if not order.forex: order.forex = ForexRate.get() order.update_amount() order.reload() if address: order.set_address(address) import application.services.jobs as Jobs #Jobs.stat.update_user_stats(str(order.customer_id)) Signals.order_created.send('system', order=order) return order @classmethod def create_from_skus(cls, customer_id, skus, logistic_provider, coupon_codes, coin=0, cash=0, address=None, **kwargs): from application.models import OrderEntry, ForexRate, Item, ItemSpec entries = [] for e in skus: availability = check_availability_and_update_stock( e['item_id'], e['sku'], e['quantity']) if not availability: return e spec = ItemSpec.objects(sku=e['sku']).first() item = Item.objects(item_id=e['item_id']).first() entry = OrderEntry(spec=spec, item=item, quantity=e['quantity']).save() entries.append(entry) order = cls(customer_id=customer_id, entries=entries, logistic_provider=logistic_provider, coupon_codes=coupon_codes, coin=coin, cash=cash, **kwargs) if not order.forex: order.forex = ForexRate.get() order.update_amount() order.reload() for e in order.entries: e.create_snapshot() if address: order.set_address(address) import application.services.jobs as Jobs #Jobs.stat.update_user_stats(str(order.customer_id)) Signals.order_created.send('system', order=order) return order @classmethod def create(cls, customer_id, entries, logistic_provider, coupon_codes, coin=0, cash=0, address=None, **kwargs): import application.models as Models order_entries = [] for entry in entries: availability = check_availability_and_update_stock( entry.item_snapshot.item_id, entry.item_spec_snapshot.sku, entry.quantity) if not availability: return entry if isinstance(entry, (Models.CartEntry, Models.OrderEntry)): e = deepcopy(entry) e.__class__ = Models.OrderEntry e.id = None order_entries.append(e.save()) # entry.delete() order = cls(customer_id=customer_id, entries=order_entries, logistic_provider=logistic_provider, coupon_codes=coupon_codes, coin=coin, cash=cash, **kwargs) if not order.forex: order.forex = Models.ForexRate.get() order.update_amount() order.reload() for e in order.entries: e.create_snapshot() if address: order.set_address(address) import application.services.jobs as Jobs #Jobs.stat.update_user_stats(str(order.customer_id)) Signals.order_created.send('system', order=order) return order @property def item_changed(self): res = False for e in entries: res = res and e.item_changed if res: return res return res def __get__(self, *args, **kwargs): order = super(Order, self).__get__(*args, **kwargs) if (not order.is_paid) and order.item_changed: order.update_entry() return order def update_entry(self): if self.is_paid: return map(lambda e: e.update_snapshot(), self.entries) self.update_amount() def set_address(self, addr): ''' Create a snapshot of `addr` and make it the address of `self`. It's important to creat a snapshot instead of referencing to the origin address object such that the detail of order's address can not be modified. ''' from application.models import Address if not isinstance(addr, Address): addr = Address.objects(id=addr).first() if not addr: return False addr_snapshot = deepcopy(addr) addr_snapshot.id = None addr_snapshot.order_id = self.id addr_snapshot.save() if self.address: self.address.delete(w=1) self.address = addr_snapshot self.save() return True @property def customer(self): from application import models as Models return Models.User.objects(id=self.customer_id).first() def create_payment(self, ptype, trader): ptype = ptype.upper() self.update_entry() self.reload() if self.order_type != ORDER_TYPE.TRANSFER: is_available = self.check_entries_avaliable() if not is_available or self.status in [ 'CANCELLED', 'ABNORMAL', 'ORDER_DELETED', 'EXPIRED' ]: return None new_payment = Payment(order=self, ptype=ptype, trader=trader).save() return new_payment def get_payment(self, ptype): ptype = ptype.upper() payments = Payment.objects(order=self, ptype=ptype).order_by('-created_at') paid_payments = payments.filter(status=PAYMENT_STATUS.PAID) if paid_payments: return paid_payments.first() else: return payments.first() @property def goods_payment(self): return self.get_payment(PAYMENT_TYPE.WITHOUT_TAX) @property def tax_payment(self): return self.get_payment(PAYMENT_TYPE.WITH_TAX) @property def refunds(self): from application.models import Refund return Refund.objects(order=self) def check_entries_avaliable(self): availability = all( map(lambda e: e.is_available or e.item_spec_snapshot.stock != -1, self.entries)) if not availability: self.status = ORDER_STATUS.EXPIRED self.save() return availability def set_paid(self): if self.is_paid: return self.is_new_customer = not bool( Order.objects(customer_id=self.customer_id, is_paid=True)) self.is_paid = True self.status = ORDER_STATUS.PAYMENT_RECEIVED self.paid_date = datetime.datetime.utcnow() self.save() from application.services.order import payment_received payment_received(self) def update_payment(self, paid_type, paid_amount, trader): if paid_type == PAYMENT_TYPE.WITHOUT_TAX and not self.is_paid and \ self.status in [ORDER_STATUS.PAYMENT_PENDING, ORDER_STATUS.WAREHOUSE_IN]: if paid_amount == self.final and trader == PAYMENT_TRADERS.PAYPAL: self.set_paid() elif paid_amount == float("%.2f" % (self.final * self.forex)) and \ trader == PAYMENT_TRADERS.WEIXIN: self.set_paid() else: current_app.logger.error( 'error at updating payment. trader: {}; ptype: {}; amount:{} order id: {}' .format(trader, paid_type, paid_amount, self.id)) self.is_payment_abnormal = True else: current_app.logger.error( 'error at updating payment. trader: {}; ptype: {}; amount:{} order id: {}' .format(trader, paid_type, paid_amount, self.id)) self.is_payment_abnormal = True self.save() @property def coin_trades(self): import application.models as Models return Models.Trade.objects(reason_id=str(self.id)) def update_logistic_status(self): if self.logistics: log_status = map(lambda m: m.detail.status, self.logistics) new_status = min(log_status, key=lambda l: LOG_STATS.index(l)) self._change_status(new_status) def _change_status(self, new_status): from application.services.noti import noti_order if self.status == new_status: return self.status = new_status self.status_modified = datetime.datetime.utcnow() self.save() if new_status in LOG_STATS: noti_order(self, new_status) Signals.order_logistic_stat_changed.send( 'Order.Logistic.Status.Changed', order=self, new_status=new_status) else: Signals.order_status_changed.send('order_status_changed', order=self, new_status=new_status) def delete_order(self): for mo in self.logistics: mo.delete(w=1) for entry in self.entries: entry.delete(w=1) import application.services.jobs as Jobs #Jobs.stat.update_user_stats(str(self.customer_id)) if self.goods_payment: self.goods_payment.delete(w=1) self.delete(w=1) def cancel_order(self, reason, status=None): for mo in self.logistics: mo.close(reason) self.extra = reason self.save() if not status: status = ORDER_STATUS.ABNORMAL self._change_status(status) for entry in self.entries: try: if entry.spec.stock != -1: entry.spec.update(inc__stock=entry.quantity, set__availability=True) entry.item.update(set__availability=True, set__status='MOD') except AttributeError: pass def update_amount(self): from application.services.price import cal_order_price_and_apply, \ cal_order_tax for e in self.entries: e.update_amount() cal_order_price_and_apply(self) self.estimated_tax = cal_order_tax(self) self.save() @property def sid(self): return self.short_id def to_json(self, include_logistic=False, replace_entries_to_refunded=False): if not self.is_paid: self.update_amount() self.reload() entries_json = [] if replace_entries_to_refunded and self.has_refund_entries(): for e in self.refund_entries: entries_json.append(e.to_json()) else: for e in self.entries: entries_json.append(e.to_json()) refund_entries_json = [] for e in self.refund_entries: refund_entries_json.append(e.to_json()) result = dict( id=str(self.id), short_id=str(self.sid), status=self.status, customer_id=str(self.customer_id), amount=self.amount, cn_shipping=self.cn_shipping, coin=self.coin, hongbao=self.hongbao, discount=self.discount, final=self.final, estimated_tax=self.estimated_tax, payment_status='PAID' if self.is_paid else 'UNPAID', payment_ref_number=[ p.ref_number for p in Payment.objects(order=self) ], created_at=format_date(self.created_at), entries=entries_json, refund_entries=refund_entries_json, refund_amount=self.refund_amount, real_tax=self.real_tax, ) if self.address: result.update({"address": self.address.to_json()}) if include_logistic: result.update(dict(logistics=[l.to_json() for l in self.logistics])) return result def to_grouped_json(self): res = { 'estimated_weight': self.estimated_weight, 'amount': self.amount, 'cn_shipping': self.cn_shipping, 'coin': self.coin, 'hongbao': self.hongbao, 'discount': self.discount, 'final': self.final, 'estimated_tax': self.estimated_tax } res['sid'] = self.sid res['status'] = self.status if self.address: res.update(dict(address=self.address.to_json())) return res
class ExpressTracking(db.Document): company = db.StringField(required=True) number = db.StringField(required=True, unique_with='company') to = db.StringField() ischeck = db.StringField(required=True, default='0') # 快递单当前签收状态,包括0在途中、1已揽收、2疑难、3已签收、4退签、5同城派送中、 # 6退回、7转单等7个状态 state = db.StringField() # Dictionary in data # { # "context":"上海分拨中心/下车扫描 ", /*内容*/ # "time":"2012-08-27 23:22:42", /*时间,原始格式*/ # "ftime":"2012-08-27 23:22:42", /*格式化后时间*/ # "status":"在途", # "areaCode":"310000000000", # "areaName":"上海市", # } data = db.ListField(db.DictField()) # time created_at = db.DateTimeField(default=datetime.utcnow, required=True) is_subscribed = db.BooleanField(default=False) modified = db.DateTimeField() retries = db.IntField(default=0) @classmethod def find(cls, company, number): cls.objects(company=company, number=number).update_one(set__company=company, set__number=number, upsert=True) return cls.objects.get(company=company, number=number) @classmethod def subscribed(cls, company, number): obj = cls.objects(company=company, number=number, is_subscribed=True) return True if obj else False @classmethod def update_info(cls, data): cls.objects(company=data['com'], number=data['nu']).update_one( set__ischeck=data['ischeck'], set__state=STATE.get(data['state']), set__data=data['data'], set__modified=datetime.utcnow(), upsert=True) @property def is_checked(self): if self.ischeck and self.ischeck == '0': return False elif self.ischeck == '1': return True @property def history(self): result = [] for d in self.data: formated = { k: v for k, v in d.items() if k in ['ftime', 'context'] } result.append(formated) return result def to_json(self): return dict(company=self.company, number=self.number, ischeck=self.ischeck, state=self.state, data=self.data)
class ExpressRequestLog(db.Document): created_at = db.DateTimeField(default=datetime.utcnow, required=True) company = db.StringField() number = db.StringField() respond = db.DictField() is_success = db.BooleanField()
class User(db.Document, UserMixin): ''' The User class contains only basic and frequently used information Superclass UserMixin can provide four authenticate methods required by Flask-Login. ''' meta = { 'db_alias': 'user_db', } name = db.StringField(required=True) account = db.EmbeddedDocumentField('UserAccount') information = db.EmbeddedDocumentField('UserInformation') selling_items = db.ListField(db.StringField()) sold_items = db.ListField(db.StringField()) owned_item = db.ListField(db.StringField()) bought_item = db.ListField(db.StringField()) roles = db.ListField(db.StringField()) # favor related (item_ids) num_favors = db.IntField(default=0, min_value=0) favor_items = db.ListField(db.StringField()) addresses = db.ListField(db.ReferenceField('Address')) default_address = db.ReferenceField('Address') verified = db.BooleanField(default=False) is_deleted = db.BooleanField(default=False) deleted_date = db.DateTimeField() def __unicode__(self): return '%s' % str(self.id) #return u'{}'.format(self.name) @property def avatar_thumb(self): return self.avatar_url[:23] + 'avatar_thumbs/80x80/' + self.avatar_url[23:] @db.queryset_manager def active(doc_cls, queryset): return queryset.filter(is_deleted=False) @property def is_admin(self): return USER_ROLE.ADMIN in self.roles @classmethod def is_verified(self): return self.verified def verify(self): self.verified = True self.save() return True def to_json(self): data = dict(name=self.name, created_at=str(self.account.created_at), id=str(self.id) ) return data @classmethod def authenticate(cls, mobile_number=None, password=None): if mobile_number: user = cls.active(account__mobile_number=mobile_number).first() else: user = None if user: authenticated = user.account.check_password(password) else: authenticated = False return user, authenticated def generate_auth_token(self, expires_in=604800): s = Serializer(current_app.config['SECRET_KEY'], expires_in=expires_in) return s.dumps({'id': str(self.id)}).decode('utf-8') @staticmethod def verify_auth_token(token): s = Serializer(current_app.config['SECRET_KEY']) try: data = s.loads(token) except: return None return User.objects(id=data['id']).first() @classmethod def create(cls, mobile_number, password, name, email=None): # account account = UserAccount(mobile_number=mobile_number, email=email, is_email_verified=True) account.password = password user = User(name=name, roles=[USER_ROLE.MEMBER], information=UserInformation(), account=account) user.save() signals.user_signup.send('system', user=user) return user
class Item(db.Document): meta = {'db_alias': 'inventory_db'} item_id = db.SequenceField(required=True, unique=True, primary_key=True) # id ## price original_price = db.FloatField(required=True, min_value=0) price = db.FloatField(required=True, min_value=0) discount = db.IntField() primary_img = db.StringField(required=True) # basic information vendor = db.StringField(required=True) vendor_id = db.StringField(required=True) brand = db.StringField(required=True) main_category = db.StringField(required=True) sub_category = db.StringField(required=True) sex_tag = db.StringField(required=True, choices=SEX_TAG) tags = db.ListField(db.StringField()) # descritpion title = db.StringField(required=True) title_en = db.StringField() description = db.StringField(default='') attributes = db.ListField(db.StringField()) # 如果有材质的话,以材质开头 information = db.ListField(db.StringField()) size_lookup = db.DictField(default={}) extra = db.DictField(default={}) status = db.StringField(default=ITEM_STATUS.NEW, required=True, choices=ITEM_STATUS) availability = db.BooleanField(default=True, required=True) # time created_at = db.DateTimeField(default=datetime.utcnow, required=True) modified = db.DateTimeField() creator = db.StringField() lookup_table = db.StringField() size_chart = db.ListField(db.StringField()) fields_to_log = { 'url', 'original_price', 'price', 'discount', 'primary_img', 'vendor', 'brand', 'main_category', 'sub_category', 'sex_tag', 'tags', 'availability', } def __unicode__(self): return '%s' % self.item_id def __repr__(self): return '%s' % self.item_id @db.queryset_manager def available_items(doc_cls, queryset): return queryset.filter(availability=True) @property def specs(self): return ItemSpec.objects(item_id=self.item_id) @property def available_specs(self): return ItemSpec.objects(item_id=self.item_id, availability=True) @property def small_thumbnail(self): return self.primary_img[:23] + 'thumbnails/150x150/' + self.primary_img[ 23:] @property def large_thumbnail(self): return self.primary_img[:23] + 'thumbnails/400x400/' + self.primary_img[ 23:] @classmethod def create(cls, item): meta = item['meta'] specs = item.get('specs', []) i = Item.objects(web_id=meta['web_id']) if i: item['meta']['status'] = ITEM_STATUS.MOD return cls.modify(item) # If category, brand and tags does not exisit then create. Category.get_category_or_create(meta['main_category'], 1) Category.get_category_or_create(meta['sub_category'], 2) Brand.get_brand_or_create(meta['brand']) Vendor.get_or_create(meta['vendor']) for tag in meta['tags']: Tag.get_tag_or_create(tag) Statistics.create(meta['main_category'], meta['sub_category'], meta['brand'], meta['tags'], meta['sex_tag']) item = Item(**meta).save() item_id = item.item_id # Keep item specs clean. Remove accidentally left useless specs. old_specs = ItemSpec.objects(item_id=item_id) for spec in old_specs: spec.delete() for spec in specs: spec['item_id'] = item_id ItemSpec(**spec).save() PriceHistory.upsert_price_history(item_id, meta['price']) return item_id @classmethod def modify(cls, new_item, current_price=None): # If the item does not exist in our db, then do not trust the coming # mod data. try: old_item = Item.objects.get(web_id=new_item['meta']['web_id']) except DoesNotExist: current_app.logger.warning( 'crawler send item not exist in db: {}'.format(new_item)) return # Old item is an mongoengine object. # New item is a dictionary. cls.update_item(old_item, new_item) old_item.save() if current_price: PriceHistory.upsert_price_history(old_item.item_id, current_price) return old_item.item_id @classmethod def update_item(cls, old_item, new_item): meta = new_item['meta'] # If category, brand and tags does not exisit then create. Category.get_category_or_create(meta['main_category'], 1) Category.get_category_or_create(meta['sub_category'], 2) Brand.get_brand_or_create(meta['brand']) Vendor.get_or_create(meta['vendor']) Statistics.create(meta['main_category'], meta['sub_category'], meta['brand'], meta['tags'], meta['sex_tag']) for k, v in meta.items(): setattr(old_item, k, v) old_item.save() @classmethod def delete_item(cls, web_id): try: item = cls.objects.get(web_id=web_id) item.status = 'DEL' item.availability = False item.save() return item.item_id except DoesNotExist: pass def to_simple_json(self): return dict(id=str(self.item_id), title=self.title, price=getattr(self, 'price_details', lambda: '')(), primary_image=self.primary_img, status=self.status) def price_details(self): return dict( price=self.price, orig_price=self.original_price, discount=ceil( ((self.original_price - self.price) / self.original_price) * 100), )
class User(db.Document, UserMixin): ''' The User class contains only basic and frequently used information Superclass UserMixin can provide four authenticate methods required by Flask-Login. ''' meta = { 'db_alias': 'user_db', } name = db.StringField(required=True) account = db.EmbeddedDocumentField('UserAccount') information = db.EmbeddedDocumentField('UserInformation') avatar_url = db.URLField(default='http://assets.maybi.cn/logo/panda.jpg') # level # 0: normal user # 1: normal member; 2: advance member # 3: premium member; 4: VIP member level = db.IntField(default=0) roles = db.ListField(db.StringField()) # whether subscribed our wechat account subscribed_mp = db.BooleanField(default=False) # favor related (item_ids) num_favors = db.IntField(default=0, min_value=0) favor_items = db.ListField(db.IntField()) addresses = db.ListField(db.ReferenceField('Address')) default_address = db.ReferenceField('Address') # favor related (post_ids) num_post_likes = db.IntField(default=0, min_value=0) like_posts = db.ListField(db.IntField()) is_deleted = db.BooleanField(default=False) deleted_date = db.DateTimeField() def __unicode__(self): return '%s' % str(self.id) #return u'{}'.format(self.name) @property def avatar_thumb(self): return self.avatar_url[:23] + 'avatar_thumbs/80x80/' + self.avatar_url[ 23:] @db.queryset_manager def active(doc_cls, queryset): return queryset.filter(is_deleted=False) @property def is_admin(self): return USER_ROLE.ADMIN in self.roles def to_json(self): data = dict(name=self.name, avatar_url=self.avatar_url, avatar_thumb=self.avatar_thumb, num_followers=self.num_followers, num_followings=self.num_followings, created_at=str(self.account.created_at), id=str(self.id)) return data @classmethod def authenticate(cls, email=None, password=None): if email: user = cls.active(account__email=email.lower()).first() else: user = None if user: authenticated = user.account.check_password(password) else: authenticated = False return user, authenticated def generate_auth_token(self, expires_in=604800): s = Serializer(current_app.config['SECRET_KEY'], expires_in=expires_in) return s.dumps({'id': str(self.id)}).decode('utf-8') @staticmethod def verify_auth_token(token): s = Serializer(current_app.config['SECRET_KEY']) try: data = s.loads(token) except: return None return User.objects(id=data['id']).first() @classmethod def create(cls, email, password, name, mobile_number=None): # account account = UserAccount(email=email.lower(), mobile_number=mobile_number, is_email_verified=True) account.password = password user = User(name=name, roles=[USER_ROLE.MEMBER], information=UserInformation(), account=account) user.save() signals.user_signup.send('system', user=user) return user
class SocialOAuth(db.Document): meta = {'indexes': ['site', 'user', ('site_uid', 'site'), 'unionid']} app = db.StringField(choices=['IOS', 'MOBILEWEB'], default='MOBILEWEB') site = db.StringField(max_length=255, required=True) site_uid = db.StringField(max_length=255, required=True, unique_with='site') unionid = db.StringField() user = db.ReferenceField('User') site_uname = db.StringField(max_length=255) access_token = db.StringField(required=True) expire_date = db.DateTimeField() refresh_token = db.StringField() # wether we can get information of this oauth can_refresh = db.BooleanField(default=True) last_active_date = db.DateTimeField() def to_json(self): return dict(site=self.site, site_uname=self.site_uname) @classmethod def create(cls, site, site_uid, site_uname, access_token, expires_in=0, refresh_token=None, email=None, mobile_number=None, gender=None, password=None, unionid=None, app='MOBILEWEB', is_email_verified=False): """ create an oauth record and an user""" oauth = cls(site=site, site_uid=site_uid, site_uname=site_uname, access_token=access_token, refresh_token=refresh_token, unionid=unionid, app=app) if not email: email = '{}-{}@maybi.cn'.format( site, hashlib.md5( (app + site + site_uid).encode('utf-8')).hexdigest()) # create an user user = User.create(email=email, mobile_number=mobile_number, password=password or site_uname, name=site_uname) user.account.is_email_verified = is_email_verified user.information.gender = gender if site == 'wechat': user.subscribed_mp = True user.save() oauth.user = user oauth.save() oauth.update_token(access_token, expires_in) return oauth def update_token(self, access_token, expires_in=0): expire_date = datetime.datetime.utcnow() + datetime.timedelta( seconds=int(expires_in)) self.update(set__access_token=access_token, set__expire_date=expire_date) def re_auth(self, access_token, expires_in, refresh_token=None, unionid=None): self.update_token(access_token, expires_in) self.update(set__refresh_token=refresh_token) if unionid: self.update(set__unionid=unionid) def update_avatar(self, url): self.user.update(set__avatar_url=url) @classmethod def get_user(cls, site, site_uid): so = cls.objects(site=site, site_uid=site_uid).first() return so.user if so else None @classmethod def refresh_active(cls, site, site_uid, dt): # ignore if document does not exist cls.objects(site=site, site_uid=site_uid).update_one(set__last_active_date=dt)
class User(db.Document, UserMixin, FavorAction): ''' The User class contains only basic and frequently used information Superclass UserMixin can provide four authenticate methods required by Flask-Login. ''' meta = { 'indexes': [ 'name', 'account.created_at', 'roles', 'level', 'account.email', 'account.is_email_verified', 'is_deleted' ], 'ordering': ['-account.created_at'] } name = db.StringField(required=True) account = db.EmbeddedDocumentField('UserAccount') information = db.EmbeddedDocumentField('UserInformation') avatar_url = db.URLField(default='http://assets.maybi.cn/logo/panda.jpg') # level # 0: normal user # 1: normal member; 2: advance member # 3: premium member; 4: VIP member level = db.IntField(default=0) roles = db.ListField(db.StringField()) addresses = db.ListField(db.ReferenceField('Address')) default_address = db.ReferenceField('Address') # followers num_followers = db.IntField(default=0, min_value=0) num_followings = db.IntField(default=0, min_value=0) followers = db.ListField(db.ReferenceField('User')) followings = db.ListField(db.ReferenceField('User')) # whether subscribed our wechat account subscribed_mp = db.BooleanField(default=False) # favor related (item_ids) num_favors = db.IntField(default=0, min_value=0) favor_items = db.ListField(db.IntField()) # favor related (post_ids) num_post_likes = db.IntField(default=0, min_value=0) like_posts = db.ListField(db.IntField()) # shopping cart cart = db.ReferenceField('Cart') # wallet wallet = db.ReferenceField('CouponWallet') is_deleted = db.BooleanField(default=False) deleted_date = db.DateTimeField() def __unicode__(self): return '%s' % str(self.id) #return u'{}'.format(self.name) @property def coin_wallet(self): import application.models as Models return Models.CoinWallet.get_or_create(user=self) @property def hongbao_wallet(self): import application.models as Models return Models.HongbaoWallet.by_user(user=self) @property def orders(self): import application.models as Models return Models.Order.objects(customer_id=self.id, is_paid=True) @property def avatar_thumb(self): return self.avatar_url[:23] + 'avatar_thumbs/80x80/' + self.avatar_url[ 23:] def used_coupon(self, code): import application.models as Models return bool( Models.Order.objects(customer_id=self.id, is_paid=True, coupon__codes__contains=code)) @db.queryset_manager def active(doc_cls, queryset): return queryset.filter(is_deleted=False) @property def is_admin(self): return USER_ROLE.ADMIN in self.roles # Follow / Following def follow(self, other): if self not in other.followers: other.followers.append(self) other.num_followers += 1 if other not in self.followings: self.followings.append(other) self.num_followings += 1 self.save() other.save() signals.site_message.send(self, dest=other.id, source=self, imgs=[self.avatar_url], noti_type=NOTI_TYPE.FOLLOW, title='') def unfollow(self, other): if self in other.followers: other.followers.remove(self) other.num_followers -= 1 if other in self.followings: self.followings.remove(other) self.num_followings -= 1 self.save() other.save() def is_following(self, other): return other in self.followings def to_json(self): data = dict(name=self.name, avatar_url=self.avatar_url, avatar_thumb=self.avatar_thumb, num_followers=self.num_followers, num_followings=self.num_followings, created_at=str(self.account.created_at), id=str(self.id)) return data @classmethod def authenticate(cls, email=None, password=None): if email: user = cls.active(account__email=email.lower()).first() else: user = None if user: authenticated = user.account.check_password(password) else: authenticated = False return user, authenticated def generate_auth_token(self, expires_in=604800): s = Serializer(current_app.config['SECRET_KEY'], expires_in=expires_in) return s.dumps({'id': str(self.id)}).decode('utf-8') @staticmethod def verify_auth_token(token): s = Serializer(current_app.config['SECRET_KEY']) try: data = s.loads(token) except: return None return User.objects(id=data['id']).first() @classmethod def create(cls, email, password, name, mobile_number=None): from application.models.coupon.wallet import CouponWallet from application.models.cart import Cart # init user account. cart = Cart() cart.save() wallet = CouponWallet() wallet.save() # account account = UserAccount(email=email.lower(), mobile_number=mobile_number, is_email_verified=True) account.password = password user = User(name=name, roles=[USER_ROLE.MEMBER], information=UserInformation(), cart=cart, wallet=wallet, account=account) user.save() signals.user_signup.send('system', user=user) return user def mark_deleted(self): if self.is_deleted: return # delete social oauth, otherwise user can still login via wechat SocialOAuth.objects(user=self).delete() self.is_deleted = True self.deleted_date = datetime.datetime.utcnow() self.save()