class OrderStatus(db.Document):
""""""
meta = {
'db_alias': 'db_order',
'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 Device(db.Document):
# 设备号
device_id = db.IntField(unique=True, required=True)
# 设备类型
device_type = db.StringField()
# 设备名
device_name = db.StringField()
# mac地址
mac_addr = db.StringField(unique=True, required=True)
# 是否在线
online = db.BooleanField(default=False)
# 最后在线时间
last_online = db.FloatField(default=time.mktime(datetime.now().timetuple()))
# 使用者的id
user_id = db.IntField()
# 定位地址
location = db.StringField()
# ip地址
ip_addr = db.StringField()
# 固件版本号
version = db.StringField()
# 创建时间
create_time = db.FloatField(default=time.mktime(datetime.now().timetuple()))
# 更新时间
update_time = db.FloatField(default=time.mktime(datetime.now().timetuple()))
def __str__(self):
return "device"
class Property(db.Document):
x = db.IntField(required=True)
y = db.IntField(required=True)
title = db.StringField(required=False)
price = db.FloatField(required=False)
description = db.StringField(required=False)
beds = db.IntField(required=True)
baths = db.IntField(required=True)
squareMeters = db.FloatField(required=True)
@classmethod
def find_in_area(cls, **kwargs):
ax = kwargs.get("ax")
bx = kwargs.get("bx")
ay = kwargs.get("ay")
by = kwargs.get("by")
properties = cls.objects(x__lte=ax, x__gte=bx, y__gte=ay, y__lte=by)
return properties
def to_dict(self):
return {
'id': str(self.id),
'x': self.x,
'y': self.y,
'title': self.title,
'price': self.price,
'description': self.description,
'beds': self.beds,
'baths': self.baths,
'squareMeters': self.squareMeters
}
class Account(db.Document):
# 用户id
account_id = db.IntField()
# 手机号
username = db.StringField(unique=True, required=True)
# 手机号
phone = db.StringField()
# email
email = db.StringField()
# 区域
phone_area = db.StringField()
# 密码, md5后的密码
password = db.StringField(max_length=50, min_length=8, required=True)
# 用户名
nickname = db.StringField()
# 登录类型
loginType = db.StringField()
# 用户id
user_id = db.StringField()
# 会话
sessionid = db.StringField()
# 创建时间
create_time = db.FloatField(
default=time.mktime(datetime.now().timetuple()))
# 更新时间
update_time = db.FloatField(
default=time.mktime(datetime.now().timetuple()))
# 账号列表，当前用户拥有的wky账号列表
devices = db.ListField(db.ReferenceField(Device))
income = db.EmbeddedDocumentField('Income')
device_info = db.EmbeddedDocumentField('DeviceInfo')
def __str__(self):
pass
class User(db.Document):
# 用户id
user_id = db.IntField()
# 手机号/email
username = db.StringField(unique=True)
# 密码
password = db.StringField(max_length=50, min_length=8, required=True)
# 用户名
name = db.StringField(unique=True)
# 性别
sex = db.StringField()
# 头像
avatar = db.StringField()
# 创建时间
create_time = db.FloatField(
default=time.mktime(datetime.now().timetuple()))
# 更新时间
update_time = db.FloatField(
default=time.mktime(datetime.now().timetuple()))
# 账号列表，当前用户拥有的wky账号列表
accounts = db.ListField(
db.ReferenceField(Account, reverse_delete_rule=db.CASCADE))
def __str__(self):
return "user"
class Config(db.Document):
"""
Configuration for the Brain.
If you make changes to this model,
you will need to drop the saved record
in the database.
$ mongo
> show dbs
> use <your db>
> db.config.drop()
Then restart the application.
"""
# Retweet probability threshold.
# The higher this is, the less the brain will retweet.
retweet_threshold = db.FloatField(required=True, default=0.9)
# Chance to act. Probability the brain will tweet.
# The lower this is, the less the brain will tweet.
chance_to_act = db.FloatField(required=True, default=0.05)
# Maximum amount of retweets in an interval.
# Cause sometimes it accidentally retweets a TON of stuff.
max_retweets = db.IntField(required=True, default=10)
# Some brain configuration.
ngram_size = db.IntField(required=True, default=1)
ramble = db.BooleanField(default=True)
spasm = db.FloatField(required=True, default=0.05)
meta = {'max_documents': 1}
class Position(db.EmbeddedDocument):
lat = db.FloatField()
lng = db.FloatField()
alt = db.FloatField()
azimuthDeviation = db.StringField()
pitch = db.FloatField()
rowWidth = db.IntField()
class Terrain(db.Document):
name = db.StringField(max_length=30, required=True)
description = db.StringField(max_length=50, required=False)
height = db.FloatField(required=True)
width = db.FloatField(required=True)
lat = db.FloatField(required=True)
lon = db.FloatField(required=True)
class Variable(db.Document):
name = db.StringField(max_length=30, required=True)
min_value = db.FloatField()
max_value = db.FloatField()
alert_max = db.FloatField()
alert_min = db.FloatField()
unit = db.StringField(max_length=5, required=True)
class StatusTable(db.Document):
trackerID = db.StringField()
timeStamp = db.StringField()
currentMode = db.StringField()
currentAngle = db.FloatField()
motor = db.StringField()
errorCode = db.StringField()
calculatedAngle = db.FloatField()
meta = {'collection': 'statusTable'}
class Coupon(db.Document):
meta = {
'db_alias': 'db_order',
'indexes': ['code', 'apply', 'expire_date', 'description'],
'strict': False,
}
scope = db.StringField(required=True,
choices=COUPON_SCOPE,
default=COUPON_SCOPE.ORDER)
coupon_type = db.StringField(default=COUPON_SCOPE.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(2022, 12, 31))
code = db.StringField(unique=True)
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)
required_new_order = db.BooleanField(default=False)
once_per_user = db.BooleanField(default=False)
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 LogisticDetail(db.EmbecedDocument):
"""物流详情"""
partner_tracking_no = db.StringField(default='', required=True)
cn_tracking_no = db.StringField(default='')
cn_logistic_name = db.StringField(default='')
carrier_tracking_no = db.StringField(default='')
partner = db.ReferenceField('Partner')
channel = db.StringField()
route = db.StringField(default='DEFAULT')
pending_review_date = db.DateTimeField()
transfer_approved_date = db.DateTimeField()
warehouse_in_date = db.DateTimeField()
payment_received_date = db.DateTimeField(default=datetime.datetime.utcnow)
processing_date = db.DateTimeField()
shipping_date = db.DateTimeField()
port_arrived_date = db.DateTimeField()
received_date = db.DateTimeField()
pending_return_date = db.DateTimeField()
returned_date = db.DateTimeField()
remarks = db.EmbededDocumentListField('LogisticRemark')
delay_details = db.EmbededDocumentListField('LogisticDelay')
irregular_details = db.EmbededDocumentListField('LogisticIrregular')
extra = db.StringField(default='')
real_weight = db.FloatField(default=0)
real_fee = db.FloatField()
modified = db.DateTimeField()
modified_by = db.StringField()
status = db.StringField(max_length=256, required=True, choices=LOG_STATUS, default=LOG_STATUS.PAYMENT_RECEIVED)
attr_by_log_status = {
'PENDING_REVIEW': 'pending_review_date',
'TRANSFER_APPROVED': 'transfer_approved_date',
'WAREHOUSE_IN': 'warehouse_in_date',
'PAYMENT_RECEIVED': 'payment_received_date',
'PROECSSING': 'processing_date',
'SHIPPING': 'shipping_date',
'PORT_ARRIVED': 'port_arrived_date',
'RECEIVED': 'received_date',
'PENDING_RETURN': 'pending_return_date',
'RETURNED': 'returned_date'
}
fields_to_log = {
'cn_tracking_no', 'partner_tracking_no', 'status', 'cn_logistic_name', 'partner', 'payment_received_date',
'shipping_date', 'processing_date', 'received_date', 'port_arrived_date', 'modified_by',
}
def next(self):
if self.status in LOG_STATUS and self.status != 'RECEIVED':
self.status = LOG_STATUS[LOG_STATUS.index(self.status) + 1]
@property
def cn_logistic(self):
return Express.objects(name=self.cn_logistic_name).first()
class OptimizeModel(db.DynamicDocument):
question_num = db.IntField(min_value=0, default=-1)
wordbase = db.DictField(default={})
weights = db.DictField(default={})
key_history_cost = db.ListField(db.FloatField(default=0))
detail_history_cost = db.ListField(db.FloatField(default=0))
complete_time = db.DateTimeField(
default=lambda: datetime.datetime.utcnow())
finish = db.BooleanField(default=True)
meta = {'collection': 'optimize'}
class ItemSpec(db.Document):
""""""
meta = {
'db_alias':
'db_inventory',
'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_prive = db.FloatField(default=0, min_value=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 '{}'.format(self.sku)
def update_spec(self, new_spec):
for k, v in new_spec.items():
setattr(self, k, v)
self.save()
class Salesman(Person.Person):
branch = db.StringField()
manager = db.RefereceField(Manager.Manager, required=True)
working_hours = db.FloatField()
base_salary = db.FloatField()
comission = db.FloatField()
def setComission(self, comission):
return None
def getTotalSalary(self):
return None
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)
quantity = db.IntField(default=1, required=True)
unit_price = db.FloatField(default=0)
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):
return '{}:({}:{})'.format(self.__class__.__name__, self.item_spec_snapshot.sku, self.quantity)
def update_amount(self):
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 ControllerInfo(db.EmbeddedDocument):
siteName = db.StringField()
siteID = db.StringField()
zoneID = db.StringField()
rowID = db.StringField()
firmwareVersion = db.StringField()
boardSerialNo = db.IntField()
threshold_wind_speed = db.FloatField()
table_length = db.FloatField()
table_width = db.FloatField()
stow = db.EmbeddedDocumentField(Stow)
limits = db.EmbeddedDocumentField(Limits)
position = db.EmbeddedDocumentField(Position)
class AnalysisModel(db.DynamicDocument):
question_num = db.IntField(min_value=0, default=-1)
exam_id = db.StringField(max_length=32)
question_id = db.StringField(max_length=32)
score_detail = db.FloatField(default=0, min_value=0)
score_key = db.FloatField(default=0, min_value=0)
voice_features = db.DictField(default={})
key_hits = db.ListField(db.FloatField(default=0))
detail_hits = db.ListField(db.ListField(db.FloatField(default=0)))
user = db.ObjectIdField()
date = db.DateTimeField()
meta = {'collection': 'analysis'}
class LogisticProvider(db.Document, WeightPrice):
meta = {
'db_alias': 'db_order',
}
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.FloatField(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)
@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 CustomerInfo(db.Document):
customer_id = db.IntField(required=True)
current_location = db.PointField(required=True)
destination_location = db.PointField(required=True)
arrival_time = db.DateTimeField(required=True)
estimated_time_stayed = db.IntField(required=True) # Minutes
budget = db.FloatField(required=True) # Dollars
class Job(db.Document):
'''
next_run_time: 下次执行时间
job_state: str 任务信息
'''
_id = db.StringField()
next_run_time = db.FloatField(required=True)
job_state = db.StringField(required=True)
meta = {'db_alias': 'base', 'collection': 'jobs', 'strict': False}
def to_json(self):
return {
"id": self._id,
"next_run_time": arrow.get(self.next_run_time).float_timestamp,
"job_state": self.job_state,
}
def __repr__(self):
return '<Trade id:\'%s\', next_run_time:\'%s\'>' % (self._id,
self.next_run_time)
@staticmethod
def get_list():
'''
获取数据
'''
datas = Job.objects.all()
result = []
for row in datas:
row = modeltoJson(row)
print('row:', row)
result.append(row)
return result
class Hospital(db.Document):
name = db.StringField()
email = db.StringField()
password = db.StringField()
address = db.StringField()
location = db.DictField(db.StringField())
blood_units = db.DictField(db.FloatField())
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.email
def create(self, obj):
self.name = obj["name"]
self.email = obj["email"]
self.password = obj["password"]
self.blood_units = obj["blood_units"]
self.address = obj["address"]
self.location = obj["location"]
class Payment(db.Document):
payment_id = db.IntField(required=True)
amount = db.FloatField(min_value=0, required=True)
order_id = db.StringField(required=True)
receipt = db.StringField(required=True)
user_id = db.IntField(min_value=0, required=True)
extra = db.DictField(default={})
razorpay_payment_id = db.StringField()
razorpay_order_id = db.StringField()
meta = {'collection': 'payments', 'indexes': ['payment_id']}
def __repr__(self):
return f'Payment(payment_id={self.payment_id})'
@classmethod
def add_document(cls, amount, user_id):
next_id = Counter.get_next_sequence_value('payments')
receipt = f'receipt_{next_id}_' + ''.join(
random.choices(string.digits, k=6))
payment = cls(payment_id=next_id,
amount=amount,
user_id=user_id,
receipt=receipt)
return payment
class HDD(db.Document):
serial = db.StringField(unique=True, max_length=40)
capacity = db.FloatField()
used = db.FloatField()
server = db.ReferenceField(Server, reverse_delete_rule=3)
mount = db.StringField(max_length=40)
status = db.StringField(max_length=255)
location = db.StringField(max_length=10)
creation_date = db.DateTimeField()
modified_date = db.DateTimeField(default=datetime.utcnow())
def save(self, *args, **kwargs):
if not self.creation_date:
self.creation_date = datetime.utcnow()
self.modified_date = datetime.utcnow()
return super(HDD, self).save(*args, **kwargs)
class Jobs(db.Document):
customer_name = db.StringField()
job_address = db.EmbeddedDocumentField(Address)
billing_address = db.EmbeddedDocumentField(Address)
email = db.EmailField()
customer_phone = db.IntField()
description = db.StringField()
size = db.StringField()
expectedStartDate = db.DateTimeField()
expectedEndDate = db.DateTimeField()
costPerWorker = db.FloatField()
assignedWorkers = db.ListField(db.ReferenceField(Worker))
costPerVehicle = db.FloatField()
assignedVehicles = db.ListField(db.ReferenceField(Vehicle))
cleaningEquipments = db.ListField(db.ReferenceField(Equipment))
status = db.BooleanField()
class ChannelProvider(db.Document):
meta = {
'db_alias': 'db_order',
}
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 Control(db.EmbeddedDocument):
name = db.StringField()
controlStatus = db.FloatField()
displayName = db.StringField()
ip = db.StringField()
userFriendlyLog = db.ListField()
type = db.StringField()
class Alert(db.Document):
alert_type = db.StringField(max_length=30, required=True)
data = db.FloatField(required=True)
description = db.StringField(max_length=1000)
terrain_object = db.ReferenceField(Terrain)
sensor_object = db.ReferenceField(Sensor)
variable_object = db.ReferenceField(Variable)
value_timestamp = db.StringField(max_length=100)
class Position(db.EmbeddedDocument):
lat = db.FloatField()
lng = db.FloatField()
alt = db.FloatField()
azimuthDeviation = db.FloatField()
pitch_east = db.FloatField()
pitch_west = db.FloatField()
rowWidth = db.FloatField()
class Data(db.Document):
user = db.StringField()
local = db.StringField()
device = db.StringField()
day = db.StringField()
hour = db.StringField()
name_sensor = db.StringField()
type_sensor = db.StringField()
model_sensor = db.StringField()
value = db.FloatField()
