class Billing(db.Document):
uid = db.StringField(min_length=UID_SIZE,
max_length=UID_SIZE,
unique=True,
required=True)
plans = db.EmbeddedDocumentField(Plan)
payments = db.EmbeddedDocumentListField(Payment)
record = db.EmbeddedDocumentListField(Record)
meta = {
'indexes': ['uid'],
}
class AfterSellBilling(db.Document):
REPLACE = 1
REFUND = 2
WAITING = 'waiting'
PROCESSING = 'processing'
REFUSED = 'refused'
DONE = 'done'
billing = db.ReferenceField(Billing, required=True)
isbn = db.StringField(required=True)
number = db.IntField(required=True, default=1)
type = db.IntField(required=True)
reason = db.StringField()
is_done = db.BooleanField(default=False) # 售后账单是否完成
canceled = db.BooleanField(default=False) # 售后账单是否已经取消
user = db.ReferenceField(User, required=True)
create_time = db.IntField(required=True, default=time_int)
process = db.StringField(default=WAITING)
process_change_time = db.IntField()
feedback = db.EmbeddedDocumentListField(BillingStatus)
carts = db.ListField(db.ReferenceField(Cart))
def change_process_status(self, next_process):
self.process = next_process
self.process_change_time = time_int()
self.save()
@classmethod
def status_to_string(cls, index):
status = {
"1": "REPLACE",
"2": "REFUND",
}
return status.get(str(index))
def save(self):
super(AfterSellBilling, self).save()
if not self.process_change_time:
self.process_change_time = self.create_time
self.save()
return self
def get_cart(self):
"""
从 billing 中找出属于该售后订单的 Cart
:return: Cart list
"""
return self.carts
all_carts = self.billing.carts
this_after_selling_carts = []
for cart in all_carts:
if isinstance(cart.in_after_selling_time, int):
if self.create_time - cart.in_after_selling_time in range(
0, 6):
this_after_selling_carts.append(cart)
return this_after_selling_carts
class Mitre(db.Document):
commands = db.EmbeddedDocumentListField('MitreCommands')
platform = db.StringField(max_length=50, default="all")
category = db.StringField(max_length=100)
technique_id = db.StringField(max_length=100,
unique_with=['platform', 'category'])
technique_name = db.StringField(max_length=100)
url = db.StringField(max_length=1000)
class DataReceived(db.EmbeddedDocument):
motorUpdate = db.EmbeddedDocumentField(Motor)
battery = db.EmbeddedDocumentField(Battery)
pv = db.EmbeddedDocumentField(Pv)
tracking = db.EmbeddedDocumentField(Tracking)
misc = db.EmbeddedDocumentField(Misc)
led = db.EmbeddedDocumentField(Led)
events = db.EmbeddedDocumentListField(Events)
class ToDo(db.Document):
created_at = db.DateTimeField(default=datetime.datetime.now, required=True)
author = db.ReferenceField(User, required=True)
title = db.StringField(max_length=100, required=True)
description = db.StringField(max_length=500, required=True)
complete = db.BooleanField(default=False, required=True)
pomodoro_length = db.IntField(require=True)
break_length = db.IntField(require=True)
long_break_length = db.IntField(require=True)
pomodoros = db.EmbeddedDocumentListField(Pomodoro)
class Cart(db.Document):
"""购物车模型类"""
meta = {'db_alias': 'db_cart', 'indexes': ['user_id', 'session_key']}
entries = db.EmbeddedDocumentListField('CartEntry')
user_id = db.StringField()
session_key = db.StringField()
def __repr__(self):
return '<Cart: {}>'.format(self.id)
class UserProfile(db.EmbeddedDocument):
updated = db.IntField(default=0)
first_name = db.StringField(max_length=50)
last_name = db.StringField(max_length=50)
public_name = db.StringField(max_length=50)
gender = db.StringField(max_length=1)
currency = db.StringField(min_length=3, max_length=3)
timezone = db.StringField(min_length=3, max_length=3)
date_of_birth = db.DateTimeField()
avatar = db.ImageField(size=(300, 300, True))
interests = db.ListField()
addresses = db.EmbeddedDocumentListField(Address)
billing = db.ReferenceField(Billing)
class Word(db.Document):
name = db.StringField(required=True)
means = db.EmbeddedDocumentListField(Mean)
tags = db.ListField(db.StringField(max_length=30))
notes = db.EmbeddedDocumentListField(Note)
exps = db.EmbeddedDocumentListField(Exp)
def to_json(self):
return {
'id': str(self.id),
'name': self.name,
'means': [{
'pos': x.pos,
'mean': x.mean
} for x in self.means],
'notes': [{
'user': x.user,
'content': x.content
} for x in self.notes],
'exps': [{
'eng': x.eng,
'chn': x.chn
} for x in self.exps]
}
class PriceHistory(db.Document):
""""""
meta = {
'db_alias': 'db_inventory',
}
item_id = db.IntField(required=True)
history = db.EmbeddedDocumentListField('Price', required=True)
@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 Projects(db.Document):
projectname = db.StringField(max_length=50, required=True, unique=True)
projectDescription = db.StringField(default="Undefined",
max_length=255,
required=False)
projectTag = db.StringField(max_length=100, required=False, unique=True)
projectCreator = db.StringField(max_length=100, required=False)
projectStartupTasks = db.EmbeddedDocumentListField('StartupTasks')
projectUsers = db.ListField(db.ReferenceField('Users'))
projectBeacons = db.ListField(db.ReferenceField('Beacons'))
meta = {
'ordering': ['-projectname'],
'allow_inheritance': True,
}
def clean(self):
if self.projectname == "":
msg = "Unable to add empty projectname"
raise ValidationError(msg)
class Users(db.Document):
username = db.StringField(max_length=50, required=True, unique=True)
password = db.StringField(max_length=128, required=True)
saltGenerator = ''.join(
random.SystemRandom().choice(string.ascii_uppercase + string.digits)
for _ in range(20))
salt = db.StringField(default=saltGenerator, max_length=20, required=True)
userRole = db.StringField(max_length=20, required=True, default="User")
userEmail = db.EmailField(required=True)
userDescription = db.StringField(default="Undefined",
max_length=255,
required=False)
userProjects = db.ListField(db.ReferenceField('Projects'))
userMacros = db.EmbeddedDocumentListField('Macros')
userMessages = db.ListField(db.StringField(max_length='1000'))
meta = {
'ordering': ['-username'],
}
def clean(self):
if self.username == "" or self.password == "" or self.userEmail == "":
msg = "Unable to add empty username and/or password"
raise ValidationError(msg)
@property
def is_authenticated(self):
return True
@property
def is_active(self):
return True
@property
def is_anonymous(self):
return False
def get_id(self):
return self.username
class User(UserMixin, db.Document):
email = db.StringField(required=True, unique=True)
username = db.StringField(required=True, unique=True)
password_hash = db.StringField(required=True)
wordtag = db.StringField(required=True, default='siji')
daycount = db.IntField(default=50)
hiswords = db.EmbeddedDocumentListField(HisWords)
curwords = db.ListField(db.ReferenceField(Word))
remainwords = db.ListField(db.ReferenceField(Word))
@property
def password(self):
raise AttributeError('password is not a readable attribute')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
def generate_auth_token(self, expiration):
s = Serializer(current_app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.id})
@staticmethod
def verify_auth_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return None
return User.objects.get_or_404(id=data['id'])
def to_json(self):
pass
class Mode(db.Document):
name = db.StringField()
controlData = db.EmbeddedDocumentListField(ControlData)
class Team(db.Document):
name = db.StringField(max_length=80,
unique=True,
verbose_name="Team name",
help_text="Basically, who are you?")
type = db.StringField(
choices=TEAM_TYPE,
required=True,
verbose_name="Type of team",
help_text="This will give you differents options after.")
description = db.StringField(max_length=255,
verbose_name="Description",
help_text="What is the purpose of your team?")
admin = db.ReferenceField(User,
required=True,
verbose_name="Administrator",
help_text="Who is the boss?")
date = db.DateTimeField(
default=datetime.now,
required=True,
verbose_name="Creation date",
help_text="Automatic field",
)
members = db.EmbeddedDocumentListField('Member',
verbose_name="Team's Members",
help_text="Who is in?")
photo = db.ImageField(thumbnail_size=(100, 100, True))
renderfields = ("name", "type", "description", "admin")
renderfieldsaslist = ("members")
actions = OrderedDict((("view", "View"), ("edit", "Edit"),
("member/invite", "Invite"), ("delete", "Delete")))
badge = "members"
@property
def iseditable(self):
return self.admin == current_user
@property
def editurl(self):
return url_for("team")
def addmember(self, usertoadd):
if usertoadd:
m = Member(user=usertoadd)
self.members.append(m)
self.save()
def removemember(self, usertoremove):
m = self.members.filter(user=usertoremove)
m.delete()
m.save()
@classmethod
def form(cls, fields=None):
if fields:
Teamform = model_form(cls, only=fields)
else:
Teamform = model_form(cls)
Teamform.photo = FileField()
Teamform.submit = SubmitField('Go')
return Teamform
def invite(self, email):
u = User.objects(email=email).first()
if u:
if self.members.filter(user=u).count() == 0:
self.addmember(u)
flash("User added", "success")
else:
flash("User allready in the team", "error")
else:
u = User(email=email).save()
self.addmember(u)
flash("Email sent", "success")
return True
def __str__(self):
return ("%s" % self.name)
class Trends(db.Document):
trendsData = db.EmbeddedDocumentListField(TrendsData)
meta = {'collection': 'trends'}
class TrendsData(db.EmbeddedDocument):
zoneId = db.StringField()
numberOfTrackers = db.StringField()
trackers = db.EmbeddedDocumentListField(Trackers)
operationalNo = db.StringField()
class Trackers(db.EmbeddedDocument):
trackerId = db.StringField()
parameters = db.EmbeddedDocumentListField(Parameter)
class Parameter(db.EmbeddedDocument):
name = db.StringField()
coordinates = db.EmbeddedDocumentListField(Coordinates)
class CouponWallet(db.Document):
meta = {
'db_alias': 'db_order',
'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_coupon(self):
for c in self.consumable_coupons:
if datetime.datetime.utcnow() >= c.coupon.expire_date + datetime.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_coupon=cc, coupon=self.coupons)
class User(db.Document, UserMixin):
id = db.StringField(required=True, unique=True, primary_key=True)
username = db.StringField()
email = db.StringField()
password = db.StringField()
description = db.StringField()
avatar = db.IntField(default=1) # the file name of avatar
school = db.StringField(required=True, default=u"华南师范大学石牌校区")
create_time = db.IntField(default=time_int, required=True)
group = db.IntField(required=True, default=1)
roles = db.ListField(db.ReferenceField(UserRole), default=[])
credits = db.IntField(required=True, default=0)
# Carts
carts = db.EmbeddedDocumentListField(UserInlineCart)
# TOKEN
token = db.StringField()
# FOR REGISTER
captcha = db.IntField()
captcha_create_time = db.IntField()
register_done = db.BooleanField(default=False)
def __unicode__(self):
return u'{}'.format(self.username)
@property
def full_link_avatar(self):
return 'https://cdn.bookist.org/avatar/{}.jpg'.format(self.avatar)
@property
def active(self):
return True
@classmethod
def phone_check(cls, phone):
users = cls.objects(pk=phone, register_done=True)
if users.count() == 1:
return False
return True
@classmethod
def get_user_on_headers(cls):
"""
直接读取 headers TOKEN 返回一个User示例
** 危险度高,慎用 **
:return: None / User实例
"""
token = request.headers.get('token', None)
if not token:
return None
this_user = cls.objects(token=token)
if this_user.count() == 1:
return this_user.first()
return None
@classmethod
def get_one_user(cls, openid=None, token=None):
"""
返回一个用户
:param openid: 用户的微信OPENID
:param token: 用户当前TOKEN
:return: None / User实例
"""
if openid and token:
this_user = cls.objects(id=openid, wechat__access_token=token)
elif openid and not token:
this_user = cls.objects(id=openid)
elif not openid and token:
this_user = cls.objects(wechat__access_token=token)
else:
return None
if this_user.count() == 1:
return this_user.first()
return None
def add_cart(self, isbn, number=1):
is_added = False
carts = list(self.carts)
for cart in carts:
if cart.book_isbn == str(isbn):
cart.number += number
cart.number = min(cart.number, 10)
is_added = True
if cart.number <= 0:
carts.remove(cart)
break
if not is_added and number > 0:
carts.append(UserInlineCart(book_isbn=isbn, number=min(number,
10)))
self.carts = carts
self.save()