class Storehouse(db.Document):
"""
储存中的书籍
"""
STATUS_NORMAL = 0
STATUS_PROCESSING = 1
STATUS_RETURNED = 2
STATUS_IN_ENTREPOT = 3
book = db.ReferenceField(Book)
price = db.DecimalField(required=True)
real_price = db.DecimalField()
create_time = db.IntField(required=True, default=time_int)
status = db.IntField(required=True, default=STATUS_NORMAL)
process_status = db.StringField()
status_changed_time = db.IntField()
source = db.StringField() # 来源地
def __eq__(self, other):
if isinstance(other, Cart):
if self.book == other.book and self.price == self.price and self.status == other.status:
return True
return False
class Posts(db.Document):
city = db.StringField(max_length=200, required=True)
uf = db.StringField(max_length=3, required=True)
latitude = db.DecimalField(max_length=60, required=True)
longitude = db.DecimalField(max_length=60, required=True)
file = db.URLField(required=True)
created_at = db.DateTimeField(default=datetime.utcnow(), required=True)
class Document(db.Document):
url = db.StringField()
title = db.StringField()
snippet = db.StringField()
sentiment = db.DecimalField()# db.EmbeddedDocumentField('Sentiment')
emotion = db.DictField() #db.EmbeddedDocumentField('Emotion') #db.DictField()
entities = db.ListField(db.DictField())
trustworthiness = db.DecimalField()
source = db.StringField()
class Cart(db.Document):
"""
订单中书籍
"""
STATUS_NORMAL = 0 # 正常状态
STATUS_REPLACE_PROCESSING = 1 # 退货处理中
STATUS_REPLACE_END = 2 # 退货结束
STATUS_REFUND_PROCESSING = 3 # 换货处理中
STATUS_REFUND_END = 4 # 换货借宿
STATUS_CANCELED = 5
book = db.ReferenceField(Book)
price = db.DecimalField(required=True)
real_price = db.DecimalField()
create_time = db.IntField(required=True, default=time_int)
status = db.IntField(required=True, default=STATUS_NORMAL)
in_after_selling_time = db.IntField()
status_changed_time = db.IntField()
user = db.ReferenceField(User)
def __unicode__(self):
return u'<Cart id({}) <{}> ${}>'.format(str(self.pk), self.book.title,
self.price)
def __eq__(self, other):
if isinstance(other, Cart):
if self.book == other.book \
and self.price == other.price \
and self.status == other.status:
if self.status != self.STATUS_NORMAL:
if self.in_after_selling_time == other.in_after_selling_time \
and self.status_changed_time == other.status_changed_time:
return True
else:
return False
else:
return True
return False
def change_status(self, next_status):
self.status = next_status
self.status_changed_time = time_int()
self.save()
@classmethod
def status_to_string(cls, index):
status = {
"0": "STATUS_NORMAL",
"1": "STATUS_REPLACE_PROCESSING",
"2": "STATUS_REPLACE_END",
"3": "STATUS_REFUND_PROCESSING",
"4": "STATUS_REFUND_END",
}
return status.get(str(index))
class JobInstance(db.Document):
instanceId = db.StringField()
jobName = db.StringField()
jobDisplayName = db.StringField()
jobJson = db.StringField() # 来自哪个job实例
jobJsonPath = db.StringField()
result = db.IntField()
executeOutput = db.StringField() # 输出结果
executeTime = db.DecimalField(default=time.time, required=True) # 执行时间
endTime = db.DecimalField(default=time.time, required=True) #执行结束时间
class Restaurant(db.Document):
profile_picture = db.StringField(
verbose_name=u'Profile Picture',
default='https://s3.amazonaws.com/foodtruckfinder45/fast-food.png')
name = db.StringField(verbose_name=u'Name', max_length=100, required=True)
email = db.EmailField(verbose_name=u'Email',
max_length=100,
required=True,
unique=True)
pwd = db.StringField(verbose_name='Password',
max_length=100,
required=True)
cuisine = db.StringField(
verbose_name=u'Cuisine',
max_length=100,
required=True,
)
isOpen = db.BooleanField(verbose_name=u'Open', default=False)
hours = db.IntField(verbose_name=u'Hours', default=0)
lat = db.DecimalField(verbose_name=u'Lat', default=0.00, precision=9)
lng = db.DecimalField(verbose_name=u'Lng', default=0.00, precision=9)
menu = db.ListField(db.DictField(verbose_name=u'Menu'))
def __unicode__(self):
return self.email
def __init__(self, *args, **kwargs):
super(Restaurant, self).__init__(*args, **kwargs)
def set_password(self, password):
self.pwd = generate_password_hash(
password,
method=current_app.config['PROJECT_PASSWORD_HASH_METHOD'])
def check_password(self, password):
return check_password_hash(self.pwd, password)
def get_token(self):
serializer = TimedSerializer(current_app.config['SECRET_KEY'])
token = serializer.dumps(self.email)
return token
def check_token_password(self, token):
serializer = TimedSerializer(current_app.config['SECRET_KEY'])
full_token = '"' + self.email + '".' + token
return serializer.loads(full_token, max_age=1800)
def change_password(self, new_password):
self.set_password(new_password)
class Sensor(db.Document):
# __tablename__ = 'sensors'
# id = db.Column(db.Integer, primary_key=True)
# name = db.Column(db.String(64), index=True)
# items = db.relationship('Item', backref='sensor', lazy='dynamic')
created_at = db.DateTimeField(default=datetime.now(), required=True)
idd = db.StringField(max_length=255, required=True, unique=True)
name = db.StringField(max_length=255, required=True)
items = db.DecimalField()
def __repr__(self):
return '<Product %r>' % self.idd
def get_url(self):
return url_for('api.get_sensor', idd=str(self.idd), _external=True)
def export_data(self):
return {'self_url': self.get_url(), 'name': self.name, 'idd': self.idd}
def import_data(self, data):
try:
self.name = data['name']
self.idd = data['idd']
except KeyError as e:
raise ValidationError('Invalid sensor: missing ' + e.args[0])
return self
class GBGrade(db.Document):
'''
A grade contains a dictionary mapping rubric sections to scores.
'''
#Map score name (eg. GrutorScore or TestScore) to scores
submission = db.ReferenceField('Submission')
scores = db.MapField(db.DecimalField())
def totalScore(self):
return sum(self.scores.values())
class customer_stats(db.Document):
category = db.IntField()
annualSpent = db.DecimalField()
ads = db.DecimalField()
aur = db.DecimalField()
upt = db.DecimalField()
numberDept = db.DecimalField()
age = db.DecimalField()
income = db.DecimalField()
category2016 = db.IntField()
class Post(db.Document):
title = db.StringField(max_length=120, required=True)
slug = db.StringField(max_length=64, unique=True)
# ReferenceField 是引用字段，在数据库中真正存储的是 ObjectID
# reverse_delete_rule=db.CASCADE 定义了，author 这个引用字段当被引用的对象删除时，它如何处理
# 比如 author 引用了用户 ross，当我们删除 ross 时，由于定义了 db.CASCADE，所以会 [级联删除] ross 用户所发表过的所有 Post 文章
author = db.ReferenceField(User, reverse_delete_rule=db.CASCADE)
category = db.ReferenceField(Category, reverse_delete_rule=db.NULLIFY)
# ListField 表明它是一个列表，可以保存多个其它类型的字段值，比如 StringField、ReferenceField、EmbeddedDocumentField 都可以
tags = db.ListField(db.ReferenceField(Tag, reverse_delete_rule=db.PULL))
comments = db.ListField(db.EmbeddedDocumentField(Comment))
# 创建的时间，建议在数据库中全部存储 UTC 时间
# default=datetime.utcnow 表明不指定此字段的值时，它会默认保存当前的时间
created_at = db.DateTimeField(default=datetime.utcnow)
# 价格。需要数学计算时，请使用 DecimalField，不要用 FloatField (计算结果不对)
price = db.DecimalField(default='0.00')
# 是否发布
published = db.BooleanField(default=True)
meta = {
'allow_inheritance': True, # 允许被继承，比如下面的 TextPost 就继承自 Post
'indexes': ['title', 'author'], # 索引字段，后续按这两个字段值查询时可以加快速度
'ordering': ['-created_at'] # 表示按 created_at 降序排列，没有减号表示升序排列
}
@queryset_manager
def live_posts(doc_cls, queryset):
'''非默认的objects查询集，此查询集只返回发布状态为True的博客文章'''
return queryset.filter(published=True)
def clean(self):
'''
MongoEngine allows you to create custom cleaning rules for your documents when calling save().
By providing a custom clean() method you can do any pre validation / data cleaning.
'''
# 如果创建Post对象时没有提供slug，则根据title自动生成；如果提供了slug，用slugify再清理
if self.slug:
self.slug = slugify(self.slug)
else:
self.slug = slugify(self.title)
# 判断slug是否唯一
filters = dict(slug=self.slug)
if self.id:
filters['id__ne'] = self.id
# 不能用 exist = self.__class__.objects(**filters)，因为可能创建 TextPost 对象时，其它子类有相同的 slug
exist = Post.objects(**filters)
if exist.count():
self.slug = "{0}-{1}".format(self.slug, random.getrandbits(32))
def __str__(self):
return self.title
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 Book(db.Document):
isbn = db.StringField(required=True, unique=True, primary_key=True)
title = db.StringField(required=True)
origin_title = db.StringField()
subtitle = db.StringField()
author = db.ListField(db.StringField())
translator = db.ListField(db.StringField())
create_time = db.IntField(default=time_int, required=True)
publish_time = db.StringField()
image = db.EmbeddedDocumentField(CDNImage, required=True)
page = db.IntField()
catelog = db.StringField()
price = db.DecimalField()
publisher = db.StringField()
description = db.StringField()
author_description = db.StringField()
tag = db.ListField(db.EmbeddedDocumentField(BookTag))
binding = db.StringField()
rate = db.FloatField()
reason = db.StringField(require=True)
enabled = db.BooleanField(default=True)
need_to_refund = db.IntField(default=0)
need_to_replace = db.IntField(default=0)
class NotBookInstance(Exception):
pass
def __unicode__(self):
return u'《{}》'.format(self.title)
def save(self):
me = super(Book, self).save()
if not me.image.is_cdn:
image_url = save_image(me.image.url, str(me.pk))
me.image.url = image_url
me.image.is_cdn = True
me.save()
return me
def add_storehouse(self, number, add_type):
if add_type == 'REFUND':
self.need_to_refund += number
self.save()
elif add_type == 'REPLACE':
self.need_to_replace += number
self.save()
class Recipe(db.DynamicDocument):
title = db.StringField(max_length=120, required=True)
author = db.ReferenceField(User, reverse_delete_rule=CASCADE)
# image of the recipe
# img = db.FileField(required=True)
# description of the recipe
desc = db.StringField(max_length=200, required=True)
# ingredient
ing = db.StringField(max_length=200, required=True)
# step??
step = db.StringField(required=True)
prl = db.StringField(required=True)
rid = db.SequenceField(required=True)
region = db.StringField(max_length=40, required=True)
ming = db.StringField(max_length=40, required=True)
kind = db.StringField(max_length=40, required=True)
works = db.ListField(ReferenceField(Dish))
ts = db.DateTimeField(default=datetime.datetime.now)
rate = db.DecimalField(default=0.0,precision=1)
ppl = db.IntField(default=1)
def get_recipe():
return Recipe.objects().first()
@staticmethod
def generate_fakes():
import json
from random import seed, randint
import os
counts = User.objects.count()
path_to_fakes = url_for("static",filename="fakes/recipes/recipes.json")
basedir = os.path.abspath(os.path.dirname(__file__))
static_path = basedir+path_to_fakes
recipes = json.load(open(static_path))
for recipe in recipes:
r = Recipe.from_json(recipe)
while 1:
try:
r.author = User.objects(id=randint(0,counts-1)).first()
break
except:
continue
r.save(force_insert=True)
class Recipe(db.DynamicDocument):
title = db.StringField(max_length=120, required=True)
author = db.ReferenceField(User, reverse_delete_rule=CASCADE)
prl = db.StringField(required=True)
desc = db.StringField(max_length=200, required=True)
ing = db.StringField(max_length=200, required=True)
step = db.StringField(required=True)
region = db.StringField(max_length=40, required=True)
ming = db.StringField(max_length=40, required=True)
kind = db.StringField(max_length=40, required=True)
works = db.ListField(ReferenceField(Dish))
ts = db.DateTimeField(default=datetime.datetime.now)
rate = db.DecimalField(default=0.0, precision=1)
ppl = db.IntField(default=1)
def get_recipe():
return Recipe.objects().first()
class GBColumn(db.Document):
'''
A column represents a single list of entries. It can be a single problem or
one days participation, or one test.
'''
name = db.StringField()
maxScore = db.DecimalField(default=0)
#Map usernames to grade entries
scores = db.MapField(db.ReferenceField('GBGrade'))
def __init__(self, name, **data):
super(GBColumn, self).__init__(**data)
self.name = name
def getUserScore(self, user):
'''Returns a single user grade'''
return self.scores[user.keyOfUsername()].totalScore()
def cleanup(self):
pass
class Pet(db.Document):
external_id = db.StringField(db_field='ei')
name = db.StringField(db_field='n')
species = db.StringField(db_field='s')
breed = db.StringField(db_field='b')
age = db.IntField(db_field='a')
store = db.ReferenceField(Store, db_field='st')
price = db.DecimalField(
db_field='p',
precision=2,
rounding='ROUND_HALF_UP'
)
sold = db.BooleanField(db_field='sl', default=False)
received_date = db.DateTimeField(db_field='rd')
sold_date = db.DateTimeField(db_field='sd')
live = db.BooleanField(db_field='l', default=True)
meta = {
'indexes': [
('external_id', 'live'),
('species', 'breed', 'live'),
('store', 'live')
]
}
class Recipe(db.DynamicDocument):
title = db.StringField(max_length=120, required=True)
author = db.ReferenceField(User, reverse_delete_rule=CASCADE)
desc = db.StringField(max_length=500, required=True)
ing = db.StringField(max_length=1000, required=True)
step = db.StringField(required=True)
prl = db.StringField(required=True)
rid = db.SequenceField(required=True)
region = db.StringField(max_length=40, required=True)
ming = db.StringField(max_length=40, required=True)
kind = db.StringField(max_length=40, required=True)
works = db.ListField(ReferenceField(Dish))
ts = db.DateTimeField(default=datetime.datetime.now)
rate = db.DecimalField(default=0.0,precision=1)
ppl = db.IntField(default=1)
def to_json(self):
recipe = {
'url':url_for('api.get_recipe',recipe_id = self.rid, _external=True),
'title':self.title,
'author_id':self.author.id,
'description':self.desc,
'ingredients':self.ing,
'steps':self.step,
'img_url':url_for('static',filename=self.prl,_external =True),
'tags':[self.region,self.ming,self.kind],
'date_created':self.ts,
'rate':str(self.rate),
'people_rated':self.ppl
}
return recipe
@staticmethod
def from_json_custom(recipe):
title = recipe.get('title')
desc = recipe.get('desc')
ing = recipe.get('ing')
prl = recipe.get('prl')
step = recipe.get('step')
tags = recipe.get('tags')
if tags:
region=tags[0]
ming = tags[1]
kind = tags[2]
if title is None or\
desc is None or step is None or\
ing is None or prl is None or\
region is None or ming is None or kind is None:
raise ValueError('field missing')
recipe = Recipe(title=title,ing=ing,prl=prl,desc=desc,step=step,
region=region,ming=ming,kind=kind)
return recipe
@staticmethod
def generate_fakes():
import json
from random import seed, randint
import os
seed()
counts = User.objects.count()
path_to_fakes = url_for("static",filename="fakes/recipes/recipes.json")
basedir = os.path.abspath(os.path.dirname(__file__))
static_path = basedir+path_to_fakes
print (static_path)
recipes = json.load(open(static_path,encoding='utf-8')).get('recipes')
# print (recipes)
for recipe in recipes:
print (json.dumps(recipe))
r = Recipe.from_json(json.dumps(recipe))
users_count = User.objects.count()
offset = randint(0,users_count-1)
print (offset)
user = User.objects[offset:].first()
print (user.id)
r.author = user
r.save(force_insert=True)
class Review(db.Document):
title = db.StringField()
content = db.StringField()
rating = db.DecimalField(min_value=1, max_value=10, precision=1)
titleparent = db.ObjectIdField()
author = db.ObjectIdField()
points = db.ListField(db.ReferenceField(ReviewPoint))
recommended = db.BooleanField()
@staticmethod
def get_by_id(id):
try:
return Review.objects.get(id=id)
except:
return None
@staticmethod
def get_by_title(title):
reviews = Review.objects.filter(titleparent=title.id)
return reviews
@staticmethod
def get_avg_rating(title):
reviews = Review.get_by_title(title)
avg = 0
review_count = reviews.count()
if review_count <= 0:
return 0
for review in reviews:
avg += review.rating
return avg / review_count
def get_author(self):
try:
return User.get_by_id(self.author)
except:
return None
def is_author(self, user):
author = self.get_author()
return author.id == getattr(user, "id", "")
def __query_points(self, point_type):
p = []
for point in self.points:
if point.role == point_type:
p.append(point)
return p
def pros(self):
return self.__query_points(ReviewPoint.PROS_ID)
def cons(self):
return self.__query_points(ReviewPoint.CONS_ID)
def pros_as_string(self):
pros = self.pros()
pros_string = []
for pro in pros:
pros_string.append(pro.content)
return pros_string
def cons_as_string(self):
cons = self.cons()
cons_string = []
for con in cons:
cons_string.append(con.content)
return cons_string
def remove_all_points(self):
for point in self.points:
point.delete
self.points = []
def put_pros(self, pros):
pros_object = []
for pro in pros:
pro_obj = ReviewPoint(content=pro,
role=ReviewPoint.PROS_ID,
parent=self.id)
pro_obj.save()
pros_object.append(pro_obj)
self.points = pros_object
def add_pros(self, pros):
for pro in pros:
pro_obj = ReviewPoint(content=pro,
role=ReviewPoint.PROS_ID,
parent=self.id)
pro_obj.save()
self.points.append(pro_obj)
def put_cons(self, cons):
cons_object = []
for con in cons:
con_obj = ReviewPoint(content=con,
role=ReviewPoint.CONS_ID,
parent=self.id)
con_obj.save()
cons_object.append(con_obj)
self.points = cons_object
def add_cons(self, cons):
for con in cons:
con_obj = ReviewPoint(content=con,
role=ReviewPoint.CONS_ID,
parent=self.id)
con_obj.save()
self.points.append(con_obj)
class Problem(db.Document):
'''
One problem that a student can submit files to.
'''
name = db.StringField()
gradeColumn = db.ReferenceField('GBColumn', reverse_delete_rule=NULLIFY)
duedate = db.DateTimeField()
#The problem rubric
rubric = db.MapField(db.DecimalField())
#List of the names of the files we test with
testfiles = db.ListField(db.StringField())
#Can students have partners
allowPartners = db.BooleanField(default=True)
#Which files must a student submit
requiredFiles = db.StringField(default=None)
strictFiles = db.StringField(default=None)
bannedFiles = db.StringField(default=None)
#URLs for grader notes and for problem specification
gradeNotes = db.StringField()
problemPage = db.StringField()
#Settings for releasing grades
releaseAutoComments = db.BooleanField(default=True)
autoGradeOnly = db.BooleanField(default=False)
#Settings for opening and closing a problem
isOpen = db.BooleanField(default=True)
#Map usernames to submission lists
studentSubmissions = db.MapField(db.EmbeddedDocumentField('StudentSubmissionList'))
meta = {"cascade": True}
def __init__(self, name, **data):
super(Problem, self).__init__(**data)
self.name = name
def getStatusCount(self):
c,a = self.getParents()
users = User.objects.filter(courseStudent=c)
ungraded = 0
ip = 0
done = 0
for u in users:
sub = self.getLatestSubmission(u)
if sub == None:
continue
if sub.status < 3:
ungraded += 1
elif sub.status == 3:
ip += 1
else:
done += 1
return ungraded, ip, done
def cleanup(self):
if self.gradeColumn != None:
self.gradeColumn.cleanup()
self.gradeColumn.delete()
for k in self.studentSubmissions:
self.studentSubmissions[k].cleanup()
def totalPoints(self):
total = 0
for k in self.rubric:
total += self.rubric[k]
return total
def getSubmissionNumber(self, user):
'''gets the number of the latest submission'''
if user.keyOfUsername() in self.studentSubmissions:
return len(self.studentSubmissions[user.keyOfUsername()].submissions)
else:
return 0
def getSubmission(self, user, subnum):
'''Returns a single submission'''
return self.studentSubmissions[user.keyOfUsername()].submissions[int(subnum)-1]
def getLatestSubmission(self, user):
'''Gets the latest submission for a user'''
if self.getSubmissionNumber(user) == 0:
return None
else:
latestSubmission = self.getSubmission(user, self.getSubmissionNumber(user))
if isinstance(latestSubmission, Submission):
return latestSubmission
else:
return None
def getParents(self):
a = AssignmentGroup.objects.get(problems=self)
c = Course.objects.get(assignments=a)
return c,a
def getFiles(self, user, subnum):
from os import listdir
from os.path import isfile, join
c, a = self.getParents()
filePath = getSubmissionPath(c, a, self, user, subnum)
return [ f for f in listdir(filePath) if isfile(join(filePath,f)) ]
def getFilePath(self, user, subnum):
c, a = self.getParents()
return getSubmissionPath(c, a, self, user, subnum)
def getTestFilePath(self):
c, a = self.getParents()
ensurePathExists(getTestPath(c, a, self))
return getTestPath(c, a, self)
def getRequiredFiles(self):
import re
if self.requiredFiles != None and len(self.requiredFiles) > 0:
return re.split(' *, *', self.requiredFiles)
else:
return []
def getStrictFiles(self):
import re
if self.strictFiles != None and len(self.strictFiles) > 0:
return re.split(' *, *', self.strictFiles)
else:
return []
def getSubmissionInfo(self, sub):
I = self.studentSubmissions.iteritems()
for key, value in self.studentSubmissions.iteritems():
if sub in value.submissions:
return User.objects.get(username=key.replace("˙",".")), (value.submissions.index(sub)+1)
return None, -1
class Menu(db.Document):
meal_name = db.StringField(max_length=50)
meal_price = db.DecimalField(precision=2)
meal_description = db.StringField()
meal_special = db.BooleanField()
class Parts(db.Document):
part_name = db.StringField(max_length=50)
part_price = db.DecimalField(precision=2)
stock = db.IntField()
image = db.ImageField()
class Bot(db.Document):
"""
Bot Document Schema
"""
_id = db.StringField(primary_key=True)
createdOn = db.DateTimeField(default=None, null=True, required=True)
isRemoved = db.BooleanField(required=True, default=False)
removedOn = db.DateTimeField(default=None, null=True)
isPublic = db.BooleanField(required=True, default=True)
price = db.DecimalField(required=True)
description = db.StringField()
keywords = db.ListField()
installations = db.IntField(default=0, required=True)
overviewMediaUrl = db.StringField()
overviewRichText = db.StringField()
marketplaceCardMediaUrl = db.StringField()
tags = db.ListField()
name = db.StringField()
botMeta = db.DictField(default={}, required=True)
meta = {'collection': 'bots', 'strict': False}
def __init__(self, *args, **kwargs):
super(Bot, self).__init__(*args, **kwargs)
if not self._id:
self._id = f"bot_{util.get_unique_id()}"
def create(self, userObj=None, *args, **kwargs):
self.createdOn = util.get_current_time()
self.isRemoved = False
self.save()
def save(self, *args, **kwargs):
super(Bot, self).save(*args, **kwargs)
return self
# return self.encode_auth_token(self.loginId)
@staticmethod
def get_by_id(bot_id):
"""
Filter a playground by Id.
:param srv_id:
:return: Bot or None
"""
return Bot.objects(_id=bot_id).first()
@staticmethod
def get_by_id_no_template(bot_id):
"""
Filter a playground by Id.
:param srv_id:
:return: Bot or None
"""
return Bot.objects(_id=bot_id).exclude("botMeta.template").first()
def remove(self):
"""
Soft deletes the user
"""
self.isRemoved = True
self.removedOn = util.get_current_time()
self.save()
@staticmethod
def get_catalog(filterObj):
if filterObj:
return Bot.objects(
Q(isPublic=True) & Q(isRemoved=False)
& Q(tags__contains=filterObj)).only('_id', 'description',
'price',
'marketplaceCardMediaUrl',
'name', 'tags').all()
else:
return Bot.objects(Q(isPublic=True) & Q(isRemoved=False)).only(
'_id', 'description', 'price', 'marketplaceCardMediaUrl',
'name', 'tags').all()
@staticmethod
def get_tags(filterObj):
res = Bot.objects(Q(isPublic=True)
& Q(isRemoved=False)).only('tags').all()
payload = []
for item in res:
payload.extend(item.tags)
return payload
@staticmethod
def search_bots(query, filter_obj, pageNum, itemsPerPage, projectId):
regex = re.compile(f".*{query}.*", re.IGNORECASE)
regex = query
bot_payload = []
if query and not filter_obj:
objects = Bot.objects(
Q(isRemoved=False) & Q(keywords__icontains=regex)).skip(
(pageNum - 1) * itemsPerPage).limit(itemsPerPage).only(
'_id', 'description', 'price',
'marketplaceCardMediaUrl', 'name', 'tags').all()
elif filter_obj and not query:
objects = Bot.get_catalog(filter_obj)
else:
objects = Bot.objects(
Q(isPublic=True) & Q(isRemoved=False)
& Q(tags__contains=filter_obj)
& Q(keywords__icontains=regex)).skip(
(pageNum - 1) * itemsPerPage).limit(itemsPerPage).only(
'_id', 'description', 'price',
'marketplaceCardMediaUrl', 'name', 'tags').all()
return objects
