class UserConfig(me.Document):
meta = {'collection': 'user_configs'}
user_id = me.IntField(required=True)
params = me.DictField()
context = me.DictField()
data = me.DictField()
class TriggerTypeDB(stormbase.StormBaseDB, stormbase.ContentPackResourceMixin,
stormbase.UIDFieldMixin, stormbase.TagsMixin):
"""Description of a specific kind/type of a trigger. The
(pack, name) tuple is expected uniquely identify a trigger in
the namespace of all triggers provided by a specific trigger_source.
Attribute:
name - Trigger type name.
pack - Name of the content pack this trigger belongs to.
trigger_source: Source that owns this trigger type.
payload_info: Meta information of the expected payload.
"""
RESOURCE_TYPE = ResourceType.TRIGGER_TYPE
UID_FIELDS = ['pack', 'name']
name = me.StringField(required=True)
pack = me.StringField(required=True, unique_with='name')
payload_schema = me.DictField()
parameters_schema = me.DictField(default={})
meta = {
'indexes':
stormbase.TagsMixin.get_indices() +
stormbase.UIDFieldMixin.get_indexes()
}
def __init__(self, *args, **values):
super(TriggerTypeDB, self).__init__(*args, **values)
self.ref = self.get_reference().ref
self.uid = self.get_uid()
class ActionDB(stormbase.StormFoundationDB, stormbase.TagsMixin,
stormbase.ContentPackResourceMixin):
"""
The system entity that represents a Stack Action/Automation in the system.
Attribute:
enabled: A flag indicating whether this action is enabled in the system.
entry_point: The entry point to the action.
runner_type: The actionrunner is used to execute the action.
parameters: The specification for parameters for the action.
"""
name = me.StringField(required=True)
ref = me.StringField(required=True)
description = me.StringField()
enabled = me.BooleanField(
required=True, default=True,
help_text='A flag indicating whether the action is enabled.')
entry_point = me.StringField(
required=True,
help_text='The entry point to the action.')
pack = me.StringField(
required=False,
help_text='Name of the content pack.',
unique_with='name')
runner_type = me.DictField(
required=True, default={},
help_text='The action runner to use for executing the action.')
parameters = me.DictField(
help_text='The specification for parameters for the action.')
notify = me.EmbeddedDocumentField(NotificationSchema)
meta = {
'indexes': stormbase.TagsMixin.get_indices()
}
class SportsData(mongoengine.Document):
# game_id = mongoengine.StringField(required=True)
game_time = mongoengine.DateTimeField()
gamble_id = mongoengine.StringField()
game_type = mongoengine.StringField(required=True)
# guest = mongoengine.ReferenceField(TeamInfo)
# host = mongoengine.ReferenceField(TeamInfo)
guest = mongoengine.DictField()
host = mongoengine.DictField()
gamble_info = mongoengine.ReferenceField(GambleInfo)
meta = {
"indexes": [
"game_time",
"game_type",
{
"fields":
["game_time", "game_type", "guest.name", "host.name"],
"unique": True,
},
]
}
def __str__(self):
return f'game type: {self.game_type}, gamble id: {self.gamble_id}'
class PropertyPool(me.Document):
id = me.StringField(default='property_pool', primary_key=True)
properties = me.DictField(field=me.DictField(
field=me.EmbeddedDocumentField(Property)))
@staticmethod
def new():
doc = PropertyPool.objects().first()
if doc is None:
#doc = PropertyPool(id=PropertyPool._default_id)
doc = PropertyPool()
doc.save()
return doc
def has_namespace(self, ns):
return ns in self.properties
def get_prop(self, ns, name=''):
"""
:return: if name is omited, a list of property under ns is return
"""
if not name:
return [p.copy() for p in self.properties[ns].values()]
prop = self.properties[ns].get(name, None)
if prop:
return prop.copy()
else:
return None
class TaskExecutionDB(stormbase.StormFoundationDB,
stormbase.ChangeRevisionFieldMixin):
RESOURCE_TYPE = types.ResourceType.EXECUTION
workflow_execution = me.StringField(required=True)
task_name = me.StringField(required=True)
task_id = me.StringField(required=True)
task_route = me.IntField(required=True, min_value=0)
task_spec = me.DictField()
delay = me.IntField(min_value=0)
itemized = me.BooleanField(default=False)
items_count = me.IntField(min_value=0)
items_concurrency = me.IntField(min_value=1)
context = me.DictField()
status = me.StringField(required=True)
result = me.DictField()
start_timestamp = db_field_types.ComplexDateTimeField(
default=date_utils.get_datetime_utc_now)
end_timestamp = db_field_types.ComplexDateTimeField()
meta = {
'indexes': [{
'fields': ['workflow_execution']
}, {
'fields': ['task_id']
}, {
'fields': ['task_id', 'task_route']
}, {
'fields': ['workflow_execution', 'task_id']
}, {
'fields': ['workflow_execution', 'task_id', 'task_route']
}]
}
class Rules(mongoengine.DynamicDocument):
username = mongoengine.StringField(required=True)
insta_username = mongoengine.StringField(required=True, unique=True)
general = mongoengine.DictField(required=True)
connection = mongoengine.DictField(required=True)
get_followers = mongoengine.DictField(required=True)
like = mongoengine.DictField(required=True)
class Video(me.Document):
"""
Schema for Video created using 'mongoengine'
Fields:
video_id (str): Youtube defined unique id for video.
title (str): Actually Youtube video name.
description (dict): Description of the video.
thumbnails (dict): Video image urls in three different sizes.
category_id (dict): Video category id provided by Youtube.
tags (str): Video tags provided by user.
channel_id (float): Owner of the video.
yt_statistics (int): Basic statistics provided by Youtube.
comments (list of Comment): Comments have sent by Youtube users to the video.
TODO:
* It is needed to add sentiment class distributions of the video according to comments sentiment analysis
* Class sentiment distrubitons must be updated peridoically.
"""
video_id = me.StringField(primary_key=True, min_length=11, max_length=11)
title = me.StringField(required=True)
description = me.MultiLineStringField(required=True, default="")
thumbnails = me.DictField(required=True)
category_id = me.IntField(required=True)
tags = me.ListField(me.StringField(), required=True)
channel_id = me.ReferenceField('Channel', required=True)
yt_statistics = me.DictField(required=True)
comments = me.ListField(me.ReferenceField('Comment'), default=list)
class ActionDB(StormFoundationDB):
"""
The system entity that represents a Stack Action/Automation in the system.
Attribute:
enabled: A flag indicating whether this action is enabled in the system.
entry_point: The entry point to the action.
runner_type: The actionrunner is used to execute the action.
parameters: The specification for parameters for the action.
"""
name = me.StringField(required=True)
description = me.StringField()
enabled = me.BooleanField(
required=True,
default=True,
help_text='A flag indicating whether the action is enabled.')
entry_point = me.StringField(required=True,
help_text='The entry point to the action.')
pack = me.StringField(required=False,
help_text='Name of the content pack.',
unique_with='name')
runner_type = me.DictField(
required=True,
default={},
help_text='The action runner to use for executing the action.')
parameters = me.DictField(
help_text='The specification for parameters for the action.')
class PackageCategory(UnitMixin, ContentUnit):
# TODO add docstring to this class
package_category_id = mongoengine.StringField(required=True)
repo_id = mongoengine.StringField(required=True)
description = mongoengine.StringField()
packagegroupids = mongoengine.ListField()
translated_description = mongoengine.DictField()
translated_name = mongoengine.DictField()
display_order = mongoengine.IntField()
name = mongoengine.StringField()
# For backward compatibility
_ns = mongoengine.StringField(default='units_package_category')
_content_type_id = mongoengine.StringField(required=True,
default='package_category')
unit_key_fields = ('package_category_id', 'repo_id')
meta = {
'indexes':
['package_category_id', 'repo_id', 'name', 'packagegroupids'],
'collection': 'units_package_category',
'allow_inheritance': False
}
SERIALIZER = serializers.PackageCategory
class PackageEnvironment(UnitMixin, ContentUnit):
# TODO add docstring to this class
package_environment_id = mongoengine.StringField(required=True)
repo_id = mongoengine.StringField(required=True)
group_ids = mongoengine.ListField()
description = mongoengine.StringField()
translated_name = mongoengine.DictField()
translated_description = mongoengine.DictField()
options = mongoengine.ListField()
display_order = mongoengine.IntField()
name = mongoengine.StringField()
# For backward compatibility
_ns = mongoengine.StringField(default='units_package_environment')
_content_type_id = mongoengine.StringField(required=True,
default='package_environment')
unit_key_fields = ('package_environment_id', 'repo_id')
meta = {
'indexes': ['package_environment_id', 'repo_id', 'name', 'group_ids'],
'collection': 'units_package_environment',
'allow_inheritance': False
}
SERIALIZER = serializers.PackageEnvironment
@property
def optional_group_ids(self):
return [d.get('group') for d in self.options]
class Stock(mongoengine.Document):
"""
商品数据模型:
individual: 是否是独立的商品(非产品子类)
attributes: 由产品生成时记录该商品的选项信息
product: 父级产品类(当individual为False时)
name: 商品名称(当individual为True时)
description: 商品描述(当individual为True时)
addition: 商品附加信息(当individual为True时)
tags: 商品标签列表(当individual为True时)
price: 商品价格
currency: 商品货币单位 ISO-4217
inventory: 商品库存数量
onsale: 商品是否上架
extensions: 扩展数据存储
"""
individual = mongoengine.BooleanField(required=True, default=False)
product = mongoengine.ReferenceField(
Product, reverse_delete_rule=mongoengine.CASCADE)
name = mongoengine.StringField()
attributes = mongoengine.DictField()
description = mongoengine.StringField()
addition = mongoengine.StringField()
tags = mongoengine.ListField(mongoengine.StringField())
price = mongoengine.FloatField()
currency = mongoengine.StringField(default=settings.General.DefaultCurrency)
inventory = mongoengine.IntField()
onsale = mongoengine.BooleanField(default=True)
extensions = mongoengine.DictField(default=dict)
class Job(doc.Document):
PENDING, RUNNING, FINISHED, TERMINATED, CACHED = ('pending', 'running', 'finished', 'terminated', 'cached')
STATE = (
(PENDING, "等待中"), (RUNNING, "创建中"), (FINISHED, "已完成"), (TERMINATED, "已中断"), (CACHED, "已缓存")
)
url = doc.StringField(max_length=255)
data = doc.StringField(max_length=10000)
param = doc.StringField(max_length=255)
vulnerable = doc.BooleanField()
ip_pool = doc.StringField(max_length=20)
ip_port = doc.DictField(max_length=10000)
redis_host = doc.StringField(max_length=20)
redis_port = doc.StringField(max_length=20)
shell_host = doc.StringField(max_length=20)
shell_port = doc.StringField(max_length=20)
authorized_keys = doc.StringField(max_length=300)
cron_command = doc.StringField(max_length=100)
payload_name = doc.StringField(max_length=20)
payload_list = doc.DictField()
payload_host = doc.StringField()
state = doc.StringField(max_length=16, choices=STATE, default=PENDING)
created = doc.DateTimeField(default=datetime.datetime.now)
def __unicode__(self):
return "{url}".format(url=self.url)
class User(me.Document):
username = me.StringField(max_length=50,
required=True,
unique=True,
validation=_not_empty)
email = me.StringField(
max_length=50, required=True, unique=True,
validation=_not_empty) # we'll add this back in later
password = me.StringField(max_length=72,
required=True,
validation=_not_empty)
projectList = me.ListField()
# will map hardware-set names to the quantity checked out for personal use
hw_sets = me.DictField()
payment_method = me.DictField(
) # Keys: 'name_on_card', 'card_number', 'cvv', 'expiration', 'zipcode'
payment_set = me.BooleanField(default=False)
bills_list = me.ListField()
is_admin = me.BooleanField(
required=True,
default=False) # admins (second level, users created by godmin)
is_godmin = me.BooleanField(
required=True,
default=False) #Original admin (highest level, can create other admin)
navColor = me.StringField()
class PopulationGeometry(mongoengine.EmbeddedDocument):
"""
Geometric shape generated by non-threshold generating Gate
Attributes
-----------
x: str
Name of the X-dimension e.g. CD3, FSC-A etc
y: str
Name of the Y-dimension e.g. CD3, FSC-A etc
transform_x: str
Transformation method applied to the x-axis
transform_y: str
Transformation method applied to the y-axis
transform_x_kwargs: dict
Transformation keyword arguments for transform method applied to the x-axis
transform_y_kwargs: str
Transformation keyword arguments for transform method applied to the y-axis
"""
x = mongoengine.StringField()
y = mongoengine.StringField()
transform_x = mongoengine.StringField()
transform_y = mongoengine.StringField()
transform_x_kwargs = mongoengine.DictField()
transform_y_kwargs = mongoengine.DictField()
meta = {'allow_inheritance': True}
class keyword_statistics(mongoengine.Document):
_id = mongoengine.StringField()
keyword = mongoengine.StringField(max_length=16)
item_num_dict = mongoengine.DictField()
old_item_num_dict = mongoengine.DictField()
last_modified = mongoengine.StringField()
# def default(self, obj):
# if isinstance(obj, datetime):
# return obj.__str__()
# return json.JSONEncoder.default(self, obj)
def sum(self):
s = 0
for q in self.item_num_dict:
s = s + int(self.item_num_dict[q])
return s
def __str__(self):
datadict = {}
datadict['news_china'] = "中国新闻网"
datadict['news_sina'] = "新浪新闻"
datadict['news_qq'] = "腾讯新闻"
datadict['weibo_tweets'] = "微博"
datadict['weibo_comment'] = "微博评论"
datadict['weibo_infomation'] = "微博用户"
items = str(self.item_num_dict)
for i in datadict:
items = items.replace(i, datadict[i])
return "关键字:" + self.keyword + ";数目:" + items
class AllCollege(mgng.Document):
name = mgng.StringField()
questions = mgng.DictField() # {question : max word count}
preferredmeta = mgng.DictField() # {field:value}
preferredwordfrequency = mgng.DictField
accepted = mgng.IntField
rejected = mgng.IntField
class Likes(mongoengine.EmbeddedDocument):
data = mongoengine.EmbeddedDocumentListField(LikeBase)
summary = mongoengine.EmbeddedDocumentField(Count)
paging = mongoengine.DictField(null=True)
cursors = mongoengine.DictField(null=True)
def __str__(self):
return "Like Object"
class ActionExecutionDB(stormbase.StormFoundationDB):
trigger = stormbase.EscapedDictField()
trigger_type = stormbase.EscapedDictField()
trigger_instance = stormbase.EscapedDictField()
rule = stormbase.EscapedDictField()
action = stormbase.EscapedDictField(required=True)
runner = stormbase.EscapedDictField(required=True)
# Only the diff between the liveaction type and what is replicated
# in the ActionExecutionDB object.
liveaction = stormbase.EscapedDictField(required=True)
status = me.StringField(required=True,
help_text='The current status of the liveaction.')
start_timestamp = ComplexDateTimeField(
default=date_utils.get_datetime_utc_now,
help_text='The timestamp when the liveaction was created.')
end_timestamp = ComplexDateTimeField(
help_text='The timestamp when the liveaction has finished.')
parameters = me.DictField(
default={},
help_text='The key-value pairs passed as to the action runner & action.'
)
result = stormbase.EscapedDynamicField(default={},
help_text='Action defined result.')
context = me.DictField(
default={},
help_text='Contextual information on the action execution.')
parent = me.StringField()
children = me.ListField(field=me.StringField())
meta = {
'indexes': [{
'fields': ['parent']
}, {
'fields': ['liveaction.id']
}, {
'fields': ['start_timestamp']
}, {
'fields': ['action.ref']
}, {
'fields': ['status']
}]
}
def mask_secrets(self, value):
result = copy.deepcopy(value)
execution_parameters = value['parameters']
parameters = {}
# pylint: disable=no-member
parameters.update(value.get('action', {}).get('parameters', {}))
parameters.update(value.get('runner', {}).get('runner_parameters', {}))
secret_parameters = get_secret_parameters(parameters=parameters)
result['parameters'] = mask_secret_parameters(
parameters=execution_parameters,
secret_parameters=secret_parameters)
return result
class TaggingSelector(BaseSelector):
ctype = 'tags'
include = me.DictField(default=lambda: {})
exclude = me.DictField(default=lambda: {})
@property
def q(self):
rtype = self._instance.selector_resource_cls._meta[
"collection"].rstrip('s')
ids = set()
for key, value in self.include.items():
query = {
'owner': self._instance.owner,
'resource_type': rtype,
'key': key,
}
if value:
query['value'] = value
ids |= set(tag.resource_id for tag in Tag.objects(**query))
# TODO: exclude items
return me.Q(id__in=ids)
def validate(self, clean=True):
for field in ['include', 'exclude']:
if getattr(self, field):
regex = re.compile(r'^[a-z0-9_-]+$')
for key, value in getattr(self, field).items():
if not key:
raise me.ValidationError('You cannot add a tag '
'without a key')
elif not regex.match(key) or (value and
not regex.match(value)):
raise me.ValidationError('Tags must be in key=value '
'format and only contain the '
'characters a-z, 0-9, _, -')
super(TaggingSelector, self).validate(clean=True)
def clean(self):
for field in ['include', 'exclude']:
if not getattr(self, field):
setattr(self, field, {})
elif not isinstance(getattr(self, field), dict):
raise me.ValidationError('%s must be a dictionary' % field)
def __str__(self):
ret = ''
if self.include:
ret += 'Include tags: %s\t' % self.include
if self.exclude:
ret += 'Exclude tags: %s' % self.exclude
return ret
def as_dict(self):
return {'type': self.ctype, 'include': self.include}
class Remarketing(me.Document, BaseModel):
user_id = me.StringField()
store_id = me.StringField()
products_seen = me.DictField()
num_seen = me.IntField()
products_carted = me.DictField()
num_carted = me.IntField()
products_purchased = me.DictField()
num_purchased = me.IntField()
total_purchased = me.FloatField()
class Widget(mongo.EmbeddedDocument):
chart_options = mongo.DictField(required=False)
config_fields = mongo.DictField(required=False)
title = mongo.StringField(required=False)
viz_type = mongo.StringField(required=True)
chart_type = mongo.StringField(required=False)
data_fields = mongo.ListField(required=False)
viz_datasets = mongo.ListField(mongo.DictField(), required=False)
show = mongo.BooleanField(default=False)
raw_data = mongo.DictField(required=False)
chart_data = mongo.ListField(required=False)
class SSN_record(db.Document):
enzyme_type = db.ReferenceField(EnzymeType)
status = db.StringField(default='Newly created')
precalculated_vis = db.DictField(default={})
num_at_alignment_score = db.DictField(default={})
identity_at_alignment_score = db.DictField(default={})
pos_at_alignment_score = db.DictField(default={})
meta = {'indexes': ['enzyme_type']}
class ActionDB(stormbase.StormFoundationDB, stormbase.TagsMixin,
stormbase.ContentPackResourceMixin, stormbase.UIDFieldMixin):
"""
The system entity that represents a Stack Action/Automation in the system.
Attribute:
enabled: A flag indicating whether this action is enabled in the system.
entry_point: The entry point to the action.
runner_type: The actionrunner is used to execute the action.
parameters: The specification for parameters for the action.
"""
RESOURCE_TYPE = ResourceType.ACTION
UID_FIELDS = ['pack', 'name']
name = me.StringField(required=True)
ref = me.StringField(required=True)
description = me.StringField()
enabled = me.BooleanField(
required=True,
default=True,
help_text='A flag indicating whether the action is enabled.')
entry_point = me.StringField(required=True,
help_text='The entry point to the action.')
pack = me.StringField(required=False,
help_text='Name of the content pack.',
unique_with='name')
runner_type = me.DictField(
required=True,
default={},
help_text='The action runner to use for executing the action.')
parameters = me.DictField(
help_text='The specification for parameters for the action.')
notify = me.EmbeddedDocumentField(NotificationSchema)
meta = {
'indexes':
stormbase.TagsMixin.get_indices() +
stormbase.UIDFieldMixin.get_indexes()
}
def __init__(self, *args, **values):
super(ActionDB, self).__init__(*args, **values)
self.ref = self.get_reference().ref
self.uid = self.get_uid()
def is_workflow(self):
"""
Return True if this action is a workflow, False otherwise.
:rtype: ``bool``
"""
return self.runner_type['name'] in WORKFLOW_RUNNER_TYPES
class DAG_Description(mongoengine.Document):
dag_name = mongoengine.StringField(required=True, max_length=200)
raw_data = mongoengine.DictField()
clean_data = mongoengine.DictField()
vis_type = mongoengine.StringField(required=True, max_length=200)
vis_title = mongoengine.StringField(max_length=120)
vis_configuration = mongoengine.DictField()
vis_text = mongoengine.StringField(max_length=400)
vis_footer = mongoengine.StringField(max_length=400)
created_at = mongoengine.DateTimeField()
updated_at = mongoengine.DateTimeField(default=datetime.now)
meta = {"collection": "dags"}
class Users(me.Document):
meta = {'collection': 'users'}
title = me.StringField(max_length=10)
name = me.StringField(max_length=50)
email = me.EmailField(unique=True)
mobile_number = me.StringField(max_length=16, unique=True)
username = me.StringField(max_length=50,
unique=True,
nullable=False,
required=True)
password = me.StringField(nullable=False, required=True)
personal_details = me.ReferenceField('PersonalDetails',
reverse_delete_rule=1)
user_type = me.StringField(
) # could be anyone of these 1. CMS 2. Applicant 3. Worker
reference_details = me.ListField(
me.ReferenceField('References', reverse_delete_rule=1))
emergency_contact_details = me.ReferenceField('EmergencyContact',
reverse_delete_rule=1)
services = me.ListField(me.ReferenceField('Services'),
reverse_delete_rule=1)
employment_history = me.ListField(me.DictField())
available_hours = me.DictField()
general_question_answers = me.ListField()
profile_completness = me.FloatField()
general_question_result = me.FloatField()
test_question_result = me.FloatField()
profile_rating = me.FloatField()
@classmethod
def find_user_by_username(cls, uname):
user = cls.objects(username=uname).first()
if not user:
return {'error': 'Ill give you a token if youre really smart'}
user = json.loads(user.to_json())
return user
@classmethod
def find_user_by_id(cls, id):
user = cls.objects(id=id).first()
if not user:
return {'error': 'Ill give you a token if youre really smart'}
user = json.loads(user.to_json())
return user
@classmethod
def get_all(cls):
return json.loads(cls.objects().to_json())
class user(mongoengine.Document):
name = mongoengine.StringField()
email = mongoengine.EmailField()
address = mongoengine.DictField()
passwordHash = mongoengine.StringField()
metaData = mongoengine.DictField()
def setPassword(self, password):
self.passwordHash = generate_password_hash(password)
def checkPassword(self, password):
return check_password_hash(self.passwordHash, password)
class User(me.Document, UserMixin):
username = me.StringField(required=True, unique=True)
email = me.StringField()
first_name = me.StringField(required=True)
last_name = me.StringField(required=True)
status = me.StringField(required=True, default='disactive')
roles = me.ListField(me.StringField(), default=['user'])
created_date = me.DateTimeField(required=True,
default=datetime.datetime.now)
updated_date = me.DateTimeField(required=True,
default=datetime.datetime.now,
auto_now=True)
resources = me.DictField()
metadata = me.DictField()
meta = {'collection': 'users'}
def has_roles(self, roles):
for role in roles:
if role in self.roles:
return True
return False
def get_teaching_assistant_class(self):
from sadhu import models
classes = models.Class.objects(teaching_assistants__user=self)
return classes
def get_image(self):
if 'google' in self.resources:
return self.resources['google'].get('picture', None)
return None
def get_enrollments(self):
return Enrollment.objects(user=self)
def enroll(self, class_):
enrollment = Enrollment.objects(user=self,
enrolled_class=class_).first()
if not enrollment:
enrollment = Enrollment(user=self, enrolled_class=class_)
enrollment.save()
if enrollment not in class_.enrollments:
class_.enrollments.append(enrollment)
class_.save()
class fieldStore(mongoengine.Document):
name = mongoengine.StringField()
fieldType = mongoengine.StringField()
details = mongoengine.DictField()
metaData = mongoengine.DictField() # Corresponding field name in WooCommerce.
category = mongoengine.ReferenceField(category)
def Schema(self):
build = {self.name: {
**{"type": self.type},
**self.details,
}}
return build
