class OrganizationDTO(mongo.Document):
"""A DTO wrapper for Organization documents."""
name = mongo.StringField(db_field='n')
address = mongo.StringField(db_field='a')
latlng = mongo.ListField(db_field='l')
types = mongo.ListField(mongo.IntField(), db_field='ts')
phone_numbers = mongo.ListField(db_field='ns')
email_key = mongo.EmailField(db_field='ek')
emails = mongo.ListField(db_field='es')
contacts = mongo.ListField(mongo.ReferenceField(ContactDTO), db_field='cs')
user_contacts = mongo.ListField(mongo.ReferenceField('UserDTO'),
db_field='us')
organization_url = mongo.StringField(db_field='u')
partners = mongo.ListField(mongo.ReferenceField('self'), db_field='ps')
facebook = mongo.URLField(db_field='f')
twitter = mongo.URLField(db_field='t')
keywords = mongo.StringField(db_field='ks')
valid = mongo.BooleanField(db_field='v', default=True)
last_updated = mongo.DateTimeField(db_field='lu')
updated_by = mongo.ObjectIdField(db_field='ub')
page_rank_info = mongo.EmbeddedDocumentField(document_type=PageRankInfoDTO,
db_field='r')
page_rank = mongo.LongField(min_value=0, db_field='pr')
page_rank_weight = mongo.FloatField(min_value=0.0,
max_value=1.0,
db_field='w')
content_weight = mongo.FloatField(min_value=0.0, db_field='c')
combined_weight = mongo.FloatField(min_value=0.0, db_field='cw')
class QueueObject(me.Document):
commitSHA = me.StringField(sparse=False,
unique=True,
unique_with=['job'],
required=True)
running = me.BooleanField() # If currently worked on
installID = me.IntField()
status = me.StringField() # To save errors etc.
# Urls to communicate with API
runUrl = me.URLField()
compareUrl = me.URLField()
# Possible SHAs to compare with
compareOptions = me.DictField() # 0_BaseSHA, 1_ForkPoint, 2_LastCommon
# TODO: Add optional Yaml overwrite here and check in test routine
# TODO: Add optional checkpoint overwrite here and check in test routine
# Custom Job Settings
# Job name
job = me.StringField(default='default-job', required=True)
customYaml = me.ReferenceField(Setup, required=False)
customCheckpoint = me.ReferenceField(Checkpoint, required=False)
jobuser = me.StringField(default='auto-generated', required=True)
def __str__(self):
output = f"Name: {self.job} | {self.commitSHA} Running: {self.running}"
return output
meta = {'indexes': ['commitSHA']}
class OrganizationProfile(me.Document):
display_name = me.StringField(max_length=64, default=None)
organization = me.ReferenceField('Organization',
required=True,
unique=True,
reverse_delete_rule=True)
url = me.URLField()
location = me.StringField()
logo = me.URLField()
contact_number = me.StringField()
created_at = me.DateTimeField(default=datetime.utcnow)
updated_at = me.DateTimeField(default=datetime.utcnow)
created_by = me.ReferenceField('User', required=False)
updated_by = me.ReferenceField('User', required=False)
is_active = me.BooleanField(default=True)
meta = {'indexes': ['organization']}
def __str__(self):
return str(self.organization)
def save(self, *args, **kwargs):
super(OrganizationProfile, self).save(*args, **kwargs)
self.reload()
def update(self, *args, **kwargs):
super(OrganizationProfile, self).update(*args, **kwargs)
self.reload()
def to_json(self, fields=None, exclude=None):
return json_dumper(self, fields, exclude)
class UniqueBook(mongoengine.Document):
"""docstring for UniqueBook"""
book = mongoengine.ReferenceField(Book)
isbn = mongoengine.StringField(max_length=100, required=True, unique=False)
image = mongoengine.URLField()
medium_image = mongoengine.URLField()
last_update = mongoengine.DateTimeField(default=datetime.datetime.now)
buy_url = mongoengine.URLField()
editeur = mongoengine.StringField(max_length=100)
class Post(mongoengine.EmbeddedDocument):
id = mongoengine.StringField(name='post_id')
picture = mongoengine.URLField()
full_picture = mongoengine.URLField()
name = mongoengine.StringField()
description = mongoengine.StringField()
caption = mongoengine.StringField()
created_time = mongoengine.StringField()
updated_time = mongoengine.StringField()
likes = mongoengine.DictField()
class Tweet(mongo.Document):
created_at = mongo.DateTimeField()
id_str = mongo.StringField(unique=True)
favorite_count = mongo.IntField()
text = mongo.StringField()
retweeted = mongo.BooleanField()
retweet_count = mongo.IntField()
link_url = mongo.URLField()
fake_news_url = mongo.URLField()
user = mongo.EmbeddedDocumentField(TwitterUser)
fact_checked = mongo.BooleanField(default=False)
class Config(me.DynamicDocument):
name = me.StringField()
date = me.DateTimeField()
commitSHA = me.StringField()
commitDate = me.DateTimeField()
commitMessage = me.StringField()
# Assumes Tests were run on same system as the files reside
system = me.StringField()
# Unique combination of Name + SHA + System + Date to prevent reupload
# sparse allows for empty unique key
unique = me.StringField(unique=True, sparse=True)
# Test setup
setup = me.ReferenceField(Setup)
# Image Link
perfImgurLink = me.URLField()
compImgurLink = me.URLField()
# Delete Hash
perfDeleteHash = me.StringField()
compDeleteHash = me.StringField()
# Merged Commit
mergedBaseSHA = me.StringField()
# Failure field
failure = me.StringField()
def __str__(self):
output = f"Name: {self.commitMessage}\n" \
f"SHA: {self.commitSHA}\n" \
f"Date: {self.date}\n" \
f"Systen: {self.system}\n" \
f"Setup: {self.setup}"
return output
# Setup indexing for faster querying
meta = {'indexes': ['commitSHA']}
@staticmethod
def checkExisting(sha: str) -> bool:
"""
Check if there already exists a config for a given sha
Args:
sha: SHA to check for
Returns:
bool: True if already existing Config
"""
c = Config.objects(
commitSHA=sha).order_by('-date').first() # Get freshest config
return c is not None
class FakeNews(mongo.Document):
fake_news_url = mongo.URLField(unique=True)
title = mongo.StringField()
thumbnail = mongo.URLField()
facebook_shares = mongo.IntField()
source = mongo.StringField()
message_1 = mongo.StringField()
message_2 = mongo.StringField()
tweets = mongo.IntField()
clicks = mongo.IntField()
replies = mongo.ListField()
correct_url = mongo.URLField()
shortened_url = mongo.URLField()
class ProductPrice(mongo.DynamicDocument):
"""
Definition of product price schema.
"""
product_id = mongo.ObjectIdField(primary_key=False)
search_term = mongo.StringField(required=True)
price = mongo.FloatField(required=True)
date = mongo.DateTimeField(default=datetime.datetime.utcnow)
shop = mongo.StringField(required=True, max_length=50)
shop_link = mongo.URLField(required=False)
image_link = mongo.URLField(required=False)
unit_price = mongo.FloatField(required=False)
unit_measure = mongo.StringField(required=False, max_length=50)
class Repo(me.DynamicEmbeddedDocument):
"""Defines a repository object from github."""
name = me.StringField(required=True)
full_name = me.StringField(required=True)
html_url = me.URLField(required=True)
description = me.StringField()
language = me.StringField()
forks_count = me.IntField()
open_issues = me.IntField()
contributors_url = me.URLField(required=True)
# Needs to be loaded from the contributors url
contributions = me.IntField(required=True)
def __init__(self, url=None, user_id=None, **kwargs):
"""Creates a new repo from the given url.
Args:
url (str): The api url to the repo to create.
user_id (int): The user id to check for in order to load the number of contributions the user has made.
Raises:
ContributorError: Raised when the user does not contribute to the given repo.
"""
# Get the repo information
if user_id is not None and url is not None:
# Get the repo information
repo_result = request('GET', url)
repo_json = repo_result.json()
# Get the contributors list so that the number of contributions the user has made can be retrieved.
contributors_result = request('GET', repo_json['contributors_url'])
contributors_json = contributors_result.json()
if not any(contributor['id'] == user_id
for contributor in contributors_json):
raise ContributorError(user_id, url)
else:
kwargs['contributions'] = next(
contributor['contributions']
for contributor in contributors_json)
kwargs.update(repo_json)
# Create the document using the super function
super().__init__(**kwargs)
class Movie(me.Document):
title = me.StringField()
year = me.IntField()
has_sequel = me.BooleanField()
imdb_url = me.URLField()
cast = me.EmbeddedDocumentListField(Star)
score = me.DecimalField()
class Project(mongoengine.Document):
user_id = mongoengine.ObjectIdField(required=False)
description = mongoengine.StringField(max_length=100)
name = mongoengine.StringField(max_length=100)
svn_url = mongoengine.URLField()
branches = mongoengine.ListField()
project_id = mongoengine.StringField(max_length=100)
init_db()
meta = {'db_alias': 'AdaGitHub', 'collection': 'Project'}
def create_project(self, user, description, name, web_url, branches,
project_id):
self.user_id = user.id
self.description = description
self.name = name
self.web_url = web_url
self.branches = branches
self.project_id = project_id
self.save()
return self
def save_repository_infos(self, user, name):
self.user_id = user.id
self.name = name
self.save()
return self
def update_repository_infos(self, name):
self.update(name=name)
return self
class Event(document.Document):
meta = {'allow_inheritance': True}
name = orm.StringField(required=True)
city = orm.StringField(required=True)
slug = orm.StringField(required=True, unique=True)
location = orm.StringField(required=True)
address = orm.StringField(required=True)
image = orm.URLField()
start_date = orm.DateTimeField(required=True)
end_date = orm.DateTimeField(required=True)
registration_end = orm.DateTimeField(required=True)
price = orm.IntField(default=0)
schedule = orm.SortedListField(orm.EmbeddedDocumentField(ScheduleItem),
ordering='time')
@classmethod
def find_event(cls, id):
try:
oid = ObjectId(id)
except:
return Event.objects(slug=id).first()
return Event.objects(id=oid).first()
class User(mongoengine.Document):
init_db()
username = mongoengine.StringField(max_length=100)
project = mongoengine.ReferenceField(Project)
access_token = mongoengine.StringField(max_length=100)
gitlab_user = mongoengine.StringField(max_length=100)
chat_id = mongoengine.StringField(max_length=100)
gitlab_user_id = mongoengine.StringField(max_length=100)
api_token = mongoengine.StringField(max_length=100)
domain = mongoengine.URLField()
meta = {'db_alias': 'AdaBot', 'collection': 'User'}
def create_user(self, username):
self.username = username
self.save()
return self
def save_gitlab_user_data(self, gitlab_user, chat_id, gitlab_user_id):
self.gitlab_user = gitlab_user
self.chat_id = chat_id
self.gitlab_user_id = gitlab_user_id
self.save()
return self
def save_gitlab_repo_data(self, project):
self.project = project
self.save()
return self
def get_user_project(self):
project = self.project
project = Project.objects(id=project.id).first()
return project
class User(document.Document):
meta = {'allow_inheritance': True}
_hidden = ['password', 'completion_token']
type = orm.StringField()
name = orm.StringField(required=True)
image = orm.URLField()
email = orm.EmailField(required=True, unique=True)
password = orm.StringField()
gender = orm.StringField()
phone = orm.StringField()
complete = orm.BooleanField(default=True)
completion_token = orm.StringField()
# Different based on context of user - whether events attended, mentored, or organized
checkins = orm.ListField(orm.ReferenceField(events.Event))
events = orm.ListField(orm.ReferenceField(events.Event))
shirt_type = orm.StringField()
shirt_size = orm.StringField()
dietary = orm.StringField()
notes = orm.MapField(orm.StringField())
stripe_id = orm.StringField()
class TweetFactCheck(mongo.Document):
fake_news_url = mongo.URLField()
clicks = mongo.IntField(default=0)
created_at = mongo.DateTimeField(default=now())
id_str = mongo.StringField(unique=True)
replied = mongo.BooleanField(default=False)
text = mongo.StringField()
class DataImport(mongo.Document):
id = mongo.UUIDField(required=False)
upload_type = mongo.StringField(required=True)
upload_format = mongo.StringField(required=True)
duplicate_content = mongo.StringField(required=True)
description = mongo.StringField(required=False)
content_status = mongo.StringField(required=False)
content_author = mongo.StringField(required=False)
upload_file = mongo.StringField(required=False)
upload_url = mongo.URLField(required=False)
upload_freq = mongo.IntField(required=False)
last_updated = mongo.DateTimeField(required=True)
fields = mongo.ListField(required=False)
name = mongo.StringField(required=True)
meta = {'allow_inheritance': True}
@property
def datatype(self):
dt = {
"0": "csv",
"1": "json",
"2": "shapefile",
"3": "geojson",
}
return dt.get(self.upload_format, "unknown")
@property
def group(self):
if self.upload_type == "0":
return "Imported from File"
else:
return "Imported from Live Feed"
class APIRecord(me.EmbeddedDocument):
title = me.StringField()
explanation = me.StringField()
url = me.URLField()
media_type = me.StringField()
concepts = me.ListField(me.StringField())
requested_date = me.DateTimeField(default=datetime.datetime.now)
class RecipeDocument(mongoengine.Document):
# Standard Schema
# id = mongoengine.UUIDField(primary_key=True)
name = mongoengine.StringField(required=True)
description = mongoengine.StringField(required=True)
image = mongoengine.StringField(required=False)
recipeYield = mongoengine.StringField(required=True, default="")
recipeIngredient = mongoengine.ListField(required=True, default=[])
recipeInstructions = mongoengine.ListField(requiredd=True, default=[])
totalTime = mongoengine.StringField(required=False)
# Mealie Specific
slug = mongoengine.StringField(required=True, unique=True)
categories = mongoengine.ListField(default=[])
tags = mongoengine.ListField(default=[])
dateAdded = mongoengine.DateTimeField(binary=True, default=datetime.date.today())
notes = mongoengine.ListField(default=[])
rating = mongoengine.IntField(required=True, default=0)
orgURL = mongoengine.URLField(required=False)
extras = mongoengine.DictField(required=False)
meta = {
"db_alias": "core",
"collection": "recipes",
}
class Comment(me.Document):
"""
Schema for Comment created using 'mongoengine'
Fields:
time_index (long): This is an integer which determines time sorted index.
comment_id (str): ID of the comment provided by Youtube.
channel_id (str): Author ID of the comment referenced to Channel.
channel_title (str): Author name of the comment referenced to Channel.
channel_thumbnail (url): Url for pic of channel.
video_id (str): Video of the comment.
text (str): Content of the comment.
likes (long): Number of likes for the comment.
time (str): Passed time after commented as string representation.
edited (bool): If comment is edited, value is True.
timestamp (long): Timestamp of comment.
has_replies (bool): If the comment is replied its value is True.
"""
time_index = me.LongField(required=True, default=0)
comment_id = me.StringField(primary_key=True)
channel_id = me.ReferenceField('Channel', required=True)
channel_title = me.StringField(required=True)
channel_thumbnail = me.URLField(required=True)
video_id = me.ReferenceField('Video', required=True)
text = me.MultiLineStringField(required=True)
likes = me.LongField(required=True, default=0)
time = me.StringField(required=True)
edited = me.BooleanField(required=True, default=False)
timestamp = me.LongField(required=True)
has_replies = me.BooleanField(required=True, default=False)
sentiment_category = me.StringField(choices=SENTIMENT_CATEGORIES)
class Info(mongoengine.DynamicDocument):
meta = {'collection': 'info'}
pub_date = mongoengine.StringField(max_length=20)
area = mongoengine.ListField(mongoengine.StringField(max_length=5))
title = mongoengine.StringField(max_length=50)
url = mongoengine.URLField(max_length=100)
price = mongoengine.StringField(max_length=10)
class Item(me.Document):
name = me.StringField(required=True)
description = me.StringField()
tags = me.ListField(me.StringField())
upc = me.StringField(uniqued=True)
color = me.StringField()
size = me.StringField()
weight = me.StringField()
dimension = me.StringField()
image = me.URLField()
category = me.StringField(required=True,
choices=CATEGORIES,
default='food')
brand = me.ReferenceField(Brand, dbref=True)
manufactory = me.ReferenceField(Manufactory, dbref=True)
sources = me.EmbeddedDocumentListField(DataSource)
status = me.StringField(required=True, default='deactivate')
created_date = me.DateTimeField(required=True,
default=datetime.datetime.utcnow)
updated_date = me.DateTimeField(required=True,
default=datetime.datetime.utcnow,
auto_now=True)
meta = {'collection': 'items'}
class Work(me.EmbeddedDocument):
name = me.StringField(required=True, max_length=40)
url = me.URLField()
position = me.StringField()
description = me.StringField()
start_date = me.DateField(required=True)
end_date = me.DateField()
class File(me.EmbeddedDocument):
"""Defines a file hosted on cloudinary as a mongoengine document."""
url = me.URLField(required=True)
key = me.StringField(required=True)
def __init__(self, file=None, public_key=None, **kwargs):
"""Creates a new file, uploading it to cloudinary.
Args:
file: The file to be uploaded to cloudinary.
public_key: The key to have the file referenced by.
"""
if file is not None and public_key is not None:
# Upload the file
upload(file, public_id=public_key)
# Get the new location
url = cloudinary_url(public_key)[0]
super(File, self).__init__(key=public_key, url=url, **kwargs)
else:
super(File, self).__init__(**kwargs)
def delete(self):
"""Deletes the file from cloudinary."""
# Delete the object from cloudinary
destroy(self.key)
class School(me.EmbeddedDocument):
"""Defines a school object for user education list."""
name = me.StringField(required=True)
degree = me.StringField(required=True)
url = me.URLField()
start_date = me.DateField(required=True)
end_date = me.DateField()
class Token(me.Document):
"""
Represents a token issued by SNI.
"""
class TokenType(str, Enum):
"""
Enumeration containing the various token types.
"""
dyn = "dyn" # Dynamic app token
per = "per" # Permanent app token
use = "use" # User token
callback = me.URLField(default=None, null=True)
"""Callback URL of the application. When a new user token is issued, the
corresponding application is notified at this URL."""
comments = me.StringField(default=str)
"""Comments"""
created_on = me.DateTimeField(default=utils.now, required=True)
"""Timestamp of the creation of this document"""
expires_on = me.DateTimeField(default=None, null=True)
"""Self explanatory"""
owner = me.ReferenceField(User,
required=True,
reverse_delete_rule=me.CASCADE)
"""Reference to the owner of this token"""
parent = me.ReferenceField("self",
default=None,
null=True,
reverse_delete_rule=me.CASCADE)
"""Optional reference to the token that has been used to create this one"""
token_type = me.StringField(choices=TokenType, required=True)
"""Token type, see :class:`sni.uac.models.Token.TokenType`"""
uuid = me.UUIDField(binary=False, unique=True)
"""
UUID of this token
Todo:
Use the document's ``_id`` field instead.
"""
meta = {
"indexes": [
{
"fields": ["expires_on"],
"expireAfterSeconds": 0,
},
],
}
def __repr__(self) -> str:
return f"<Token: {repr(self.owner)} {self.token_type}>"
class LinkAttachment(Attachment):
"""
This class defines document type for link attachments
"""
link_url = mongoengine.URLField(required=True)
link_caption = mongoengine.StringField(default='', required=True)
link_description = mongoengine.StringField(default='', required=True)
class Widget(mongoengine.EmbeddedDocument):
id = mongoengine.IntField(default=3) #format (YYYYMMMDDXXX)
name = mongoengine.StringField()
typeOfGraph = mongoengine.StringField(required=True)
dateCreated = mongoengine.DateTimeField(default=datetime.datetime.now())
url = mongoengine.URLField(required=True)
priority = mongoengine.IntField(default=3)
options = mongoengine.ListField(mongoengine.EmbeddedDocumentField(Query))
meta = {'ordering': ['-priority']}
class Item(mongoengine.Document):
name = mongoengine.StringField(required=True)
manufacturer = mongoengine.StringField()
price = mongoengine.IntField()
stock = mongoengine.BooleanField(required=True)
url = mongoengine.URLField(required=True)
lastStocked = mongoengine.DateTimeField()
date_added = mongoengine.DateTimeField()
img_url = mongoengine.URLField(required=True)
meta = {'collection': 'items'}
def __str__(self) -> str:
if self.stock:
stock_msg = "# **In stock**"
else:
stock_msg = '> Out of stock'
return "{}\n[${}]({})\n{}\n < Last in stock: {} >\n".format(
self.name, self.price, self.url, stock_msg, self.lastStocked)
class Script(Engine.Document):
title = Engine.StringField(required=True, max_length=25, min_length=5)
author = Engine.StringField(required=True)
description = Engine.StringField()
link = Engine.URLField(unique=True, required=True)
stars = Engine.IntField(default=0)
comments = Engine.EmbeddedDocumentListField(Comment)
upvoted_by = Engine.ListField(Engine.ObjectIdField())
date_time = Engine.DateTimeField(required=True)
meta = {'collection': 'scripts'}
