class Clean_data(db.EmbeddedDocument):
meta = {
'strict' : False
}
grid = db.StringField()
payload = db.FileField()
context_type = db.StringField()
class PatchSub(db.EmbeddedDocument):
meta = {
'strict' : False
}
grid = db.StringField()
payload = db.ObjectIdField()
context_type = db.StringField()
class MiddlewareDB(db.Document):
meta = {'collection': 'middleware'}
temperature = db.FloatField(required=False)
noise = db.BooleanField(required=False)
light = db.BooleanField(required=False)
motion = db.BooleanField(required=False)
data_from = db.StringField(max_length=50, required=False)
environment = db.StringField(max_length=50, required=False)
created_at = db.DateTimeField(default=datetime.utcnow(), required=False)
class Input(db.EmbeddedDocument):
meta = {
'strict' : False
}
msg = db.StringField()
start = db.StringField()
filename = db.StringField()
trigger = db.StringField()
path = db.StringField()
class User(db.Document, UserMixin):
email = db.StringField(max_length=255)
password = db.StringField(max_length=255)
active = db.BooleanField(default=True)
confirmed_at = db.DateTimeField()
roles = db.ListField(db.ReferenceField(Role), default=[])
name = db.StringField(max_length=255)
username = db.StringField(max_length=255)
howls = ListField(ReferenceField('Howl'))
def __unicode__(self):
return self.username
class Loan(db.Document):
user = db.ReferenceField(User)
movie = db.ReferenceField(Movie, unique_with=['user'])
lent_date = db.DateTimeField(default=datetime.datetime.now, required=True)
expected_return_date = db.DateTimeField(default=datetime.datetime.now,
required=True)
borrower_email = db.StringField()
@staticmethod
def create(user, movie, email, expected_return_date=None):
info = Loan(user=user, movie=movie, borrower_email=email)
if expected_return_date:
info.expected_return_date = expected_return_date
else:
info.expected_return_date = info.expected_return_date + datetime.timedelta(
days=7)
info.save()
return info
def __str__(self):
return "%s due %s" % (self.movie.title,
self.expected_return_date.isoformat())
def __repr__(self):
return self.__str__()
class Nifi(db.Document):
meta = {
'strict' : False
}
uuid = db.StringField()
source = db.StringField()
model = db.StringField()
state = db.StringField()
result = db.StringField()
input = db.EmbeddedDocumentField(Input)
input_data = db.EmbeddedDocumentField(Input_data)
translate = db.EmbeddedDocumentField(Translate)
translate_data = db.EmbeddedDocumentField(Translate_data)
ocr = db.EmbeddedDocumentField(Ocr)
ocr_data = db.EmbeddedDocumentField(Ocr_data)
clean_data = db.EmbeddedDocumentField(Clean_data)
complete = db.EmbeddedDocumentField(Complete)
route = db.EmbeddedDocumentField(Route)
class EnvironmentDB(db.Document):
meta = {'collection': 'environment'}
name = db.StringField(max_length=50, unique=True, required=True)
temperature = db.FloatField(required=True)
noise = db.BooleanField(required=True)
light = db.BooleanField(required=True)
motion = db.BooleanField(required=False)
people = db.ListField(db.ReferenceField(PersonDB))
class Howl(db.Document):
created_at = db.DateTimeField(default=datetime.datetime.now, required=True)
howl = db.StringField(max_length=140, required=True)
user = ReferenceField(User)
def __unicode__(self):
return self.howl
meta = {'indexes': ['-created_at'], 'ordering': ['-created_at']}
class Group(db.Document):
category = db.StringField(max_length=50, required=True)
tags = db.ListField(db.StringField(max_length=50))
def addTag(self, tag):
if tag not in self.tags:
self.tags.append(tag)
return self
def removeTag(self, tag):
if tag in self.tags:
self.tags.remove(tag)
return self
def __str__(self):
return "Category: %s - %s" % (self.category, self.tags)
def __repr__(self):
return "{%s}" % (self.category)
class PatchMain(db.Document):
meta = {
'strict' : False,
'collection': 'nifi'
}
uuid = db.StringField()
input_data = db.EmbeddedDocumentField(PatchSub)
translate_data = db.EmbeddedDocumentField(PatchSub)
ocr_data = db.EmbeddedDocumentField(PatchSub)
clean_data = db.EmbeddedDocumentField(PatchSub)
class TaskModel(db.Document):
name = db.StringField(required=True)
description = db.StringField()
duration = db.IntField()
startdate = db.DateTimeField()
status = db.BooleanField(default=True) #convert to enum
# shouldnt need this on task model
def encode_auth_token(self, user_id):
try:
payload = {
'exp':
datetime.datetime.utcnow() + datetime.timedelta(
days=current_app.config.get('TOKEN_EXPIRATION_DAYS'),
seconds=current_app.config.get(
'TOKEN_EXPIRATION_SECONDS')),
'iat':
datetime.datetime.utcnow(),
'sub': {
'id': str(user_id)
}
}
return jwt.encode(payload,
current_app.config.get('SECRET_KEY'),
algorithm='HS256')
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
try:
payload = jwt.decode(auth_token,
current_app.config.get('SECRET_KEY'))
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
class Role(db.Document, RoleMixin):
name = db.StringField(max_length=80, unique=True)
description = db.StringField(max_length=255)
class MiddlewareStrategyDB(db.Document):
meta = {'collection': 'strategy'}
event = db.StringField(max_length=150, required=False)
command = db.StringField(max_length=150, required=False)
created_at = db.DateTimeField(default=datetime.utcnow(), required=False)
class MiddlewareDisconnectedDevicesDB(db.Document):
meta = {'collection': 'disconnected devices'}
name = db.StringField(max_length=50, required=False)
environment = db.StringField(max_length=50, required=False)
created_at = db.DateTimeField(default=datetime.utcnow(), required=False)
class Product(db.Document):
'''
Defining the storage containers for the data we
plan to scrape
'''
product_id = db.StringField(unique=True)
title = db.StringField()
description = db.StringField()
link = db.URLField()
image_link = db.URLField()
color = db.StringField()
size = db.StringField()
pattern = db.StringField()
material = db.StringField()
gender = db.StringField()
# #Shopify fields
product_type = db.StringField()
brand = db.StringField()
gtin = db.StringField()
mpn = db.StringField()
price = db.StringField()
compare_at_price = db.StringField()
sale_price = db.StringField()
tags = db.StringField()
# #Facebook fields
labels = db.StringField()
availability = db.StringField()
condition = db.StringField()
item_group_id = db.StringField()
shipping_weight = db.StringField()
# #Google fields
google_product_category = db.StringField()
custom_label_0 = db.StringField()
custom_label_1 = db.StringField()
custom_label_2 = db.StringField()
custom_label_3 = db.StringField()
custom_label_4 = db.StringField()
age_group = db.StringField()
# locale data(title, description and maybe something else)
locale = db.StringField()
meta = {
'collection': 'Product',
'strict': False
}
class Library(db.Document):
user = db.ReferenceField(User.User)
unit = db.StringField(
max_length=50) #what Document the Library's collection relates to
name = db.StringField(max_length=100,
unique_with=['user', 'unit']) #name of the Library
lookup_attribute = db.StringField(default='id')
collection = db.ListField(db.StringField())
def addUnit(self, unit):
if self.unit == type(unit).__name__:
value = str(unit[self.lookup_attribute])
if value is not None and value not in self.collection:
self.collection.append(value)
self.save()
else:
return self
else:
raise Exception("Cannot add %s to Library of %s" %
(type(unit).__name__, self.unit))
return self
def removeUnit(self, unit):
if self.unit == type(unit).__name__:
value = str(unit[self.lookup_attribute])
if value is not None and value in self.collection:
self.collection.remove(value)
self.save()
else:
return self
else:
raise Exception("Cannot remove %s from Library of %s" %
(type(unit).__name__, self.unit))
return self
# @param index --represents the index in the Library collection of the object
def hydrateUnit(self, index):
if index < 0 or index > self.collection.count:
return None
attr = {}
attr[self.lookup_attribute] = self.collection[index]
model = getattr(sys.modules["project.model.%s" % self.unit], self.unit)
return model.objects(**attr).first()
def hydrateList(self):
hydratedCollection = []
model = getattr(sys.modules["project.model.%s" % self.unit], self.unit)
for index, hash_value in enumerate(self.collection):
attr = {}
attr[self.lookup_attribute] = self.collection[index]
unit = model.objects(**attr).first()
hydratedCollection.append(unit)
return hydratedCollection
def searchCollection(self, keyword, exclude=[], heirarchy=[]):
"""
Searches the collection of this library for matches to the keyword
keyword String: keyword to search for
exclude List: list of attributes to exclude from the search
heirarchy List: order that matches should be returned
(first matches returned are always matches of multiple categories)
Return List of unique matches ordered by heirarchy if provided else by attribute order of object
"""
import datetime
hydratedCollection = self.hydrateList()
model = getattr(sys.modules["project.model.%s" % self.unit], self.unit)
model_attributes = model.__dict__['_db_field_map'].keys()
model_attributes = self.diff(model_attributes, exclude)
if len(heirarchy) > 0:
model_attributes = self.ordered_union(heirarchy, model_attributes)
result = [[]]
for attr in model_attributes:
result.append([])
for unit in hydratedCollection:
for index, attr in enumerate(model_attributes):
value = unit[attr]
if isinstance(value, datetime.datetime):
value = value.isoformat()
if isinstance(value,
list) and keyword.lower() in (val.lower()
for val in value):
result[index].append(unit)
elif isinstance(
value,
basestring) and keyword.lower() in value.lower():
result[index].append(unit)
groups = Group.Group.objects(tags=keyword)
for group in groups:
if self.similar(group.tags, value):
result[-1].append(unit)
break
finish_result = []
for index, r in enumerate(result[:-1]):
for val in r:
for s in result[index:]:
if val in s:
if val not in finish_result:
finish_result.append(val)
for r in result:
additions = self.diff(r, finish_result)
finish_result.extend(additions)
return finish_result
@staticmethod
def diff(a, b):
b = set(b)
return [aa for aa in a if aa not in b]
@staticmethod
def ordered_intersect(a, b):
b = set(b)
return [aa for aa in a if aa in b]
@staticmethod
def ordered_union(a, b):
a.extend(Library.diff(b, a))
return a
@staticmethod
def similar(a, b):
for val in a:
if val in b:
return True
return False
def __str__(self):
return "Library {%s-%s}" % (self.name, self.unit)
def __repr__(self):
return self.__str__()
class Peserta(db.Document):
email = db.EmailField(required=True, Unique=True)
name = db.StringField(required=True)
affiliation = db.StringField(required=True)
interest = db.StringField()
class SkillModel(db.Document):
name = db.StringField(required=True)
level = db.StringField(
required=True,
unique_with="name") # make name and level unique together
description = db.StringField()
class Route(db.EmbeddedDocument):
meta = {
'strict' : False
}
msg = db.StringField()
start = db.StringField()
class Address(db.EmbeddedDocument):
street_address = db.StringField()
city = db.StringField()
postal_code = db.StringField()
country = db.StringField()
class PersonModel(db.Document):
meta = {
'indexes': [{
'fields': [
'$username', '$firstname', '$lastname', '$job_title',
'$department'
],
'default_language':
'english'
}]
}
username = db.StringField(required=True, unique=True)
title = db.StringField()
firstname = db.StringField(required=True)
lastname = db.StringField(required=True)
email = db.EmailField()
gender = db.StringField()
job_title = db.StringField()
department = db.StringField()
avatar = db.URLField()
employeenumber = db.IntField()
address = db.EmbeddedDocumentField(Address)
startdate = db.DateTimeField()
active = db.BooleanField(default=True)
password = db.StringField()
admin = db.BooleanField(default=False, required=True)
skills = db.ListField(db.ReferenceField(SkillModel), default=[])
def clean(self):
self.password = bcrypt.generate_password_hash(
self.password,
current_app.config.get('BCRYPT_LOG_ROUNDS')).decode()
def encode_auth_token(self, user_id):
try:
payload = {
'exp':
datetime.datetime.utcnow() + datetime.timedelta(
days=current_app.config.get('TOKEN_EXPIRATION_DAYS'),
seconds=current_app.config.get(
'TOKEN_EXPIRATION_SECONDS')),
'iat':
datetime.datetime.utcnow(),
'sub': {
'id': str(user_id),
'admin': self.admin,
'active': self.active
}
}
return jwt.encode(payload,
current_app.config.get('SECRET_KEY'),
algorithm='HS256')
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
try:
payload = jwt.decode(auth_token,
current_app.config.get('SECRET_KEY'))
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
@classmethod
def pre_save(cls, sender, document, **kwargs):
print(document)
class User(db.Document, UserMixin):
name = db.StringField(max_length=50)
username = db.StringField(max_length=50)
password = db.StringField(max_length=255)
auth_token = db.StringField()
def __str__(self) -> str:
op = '{{' \
'name: {}, ' \
'email: {}, ' \
'username: {}, ' \
'}}'.format(self.name,
self.email,
self.username
)
return op
def hash_password(self, password: str) -> None:
"""
Hash the password entered by the user during sign up.
:param password: password received in request to encrypt
:type password: str
"""
self.password = sha256_crypt.hash(password)
def verify_password(self, password: str) -> bool:
"""
Verified the password entered by the user.
:rtype: bool
:param password: password received in request to verify
:type password: str
:return: True if password is verified
"""
return sha256_crypt.verify(password, self.password)
def set_auth_token(self) -> None:
"""
Sets authentication token for first login.
"""
s = Serializer(app.config['SECRET_KEY'], expires_in=10000000)
self.auth_token = s.dumps({'username': self.username}).decode('utf-8')
def set_new_auth_token(self) -> None:
"""
Sets new authentication token once user sign out.
"""
s = Serializer(app.config['SECRET_KEY'], expires_in=10000000)
self.auth_token = s.dumps({'username': self.username}).decode('utf-8')
self.save()
@staticmethod
def verify_auth_token(token: str) -> object:
"""
:param token: the token received in the authorization
:return: User object if token is valid, else None
:rtype: User
"""
s = Serializer(app.config['SECRET_KEY'])
try:
data = s.loads(token)
except SignatureExpired as e:
return None # valid token, but expired
except BadSignature as e:
return None # invalid token
user = User.objects.get(username=data['username'])
if user and token == user.auth_token:
return user
else:
return None
def create_user(self, name: str, username: str, password: str) -> bool:
"""
:param name: The name received in the request
:param username: The username received in the request
:param password: The password received in the request
:return: True if the user is created else False
:rtype: bool
"""
try:
self.name = name
self.username = username
self.set_auth_token()
self.hash_password(password)
self.save()
return True
except Exception as e:
msg = e.message
return False
class User(db.Document):
created = db.DateTimeField(default=datetime.datetime.now(), required=True)
email = db.StringField(max_length=255, required=True, unique=True)
salt = db.StringField(max_length=255, required=True)
password = db.StringField(max_length=255, required=True)
roles = db.ListField(db.StringField(max_length=50))
def hasRole(self, role):
return role in self.roles
def addRole(self, role):
if role not in self.roles:
self.roles.append(role)
return self
def removeRole(self, role):
if role in self.roles:
self.roles.remove(role)
return self
def changePassword(self, password):
self.password = hashlib.sha224(self.salt.join(password)).hexdigest()
self.save()
return self
def toJSON(self):
import json
return json.dumps({
'created': self.created.isoformat(),
'email': self.email,
'roles': self.roles,
'id': str(self.id)
})
@staticmethod
def createUser(email, password):
user = User(email=email)
user.salt = str(random.getrandbits(128))
user.password = hashlib.sha224(user.salt.join(password)).hexdigest()
user.save()
return user
@staticmethod
def validateUser(email, password):
user = User.objects(email=email).first()
if user == None:
return None
password = hashlib.sha224(user.salt.join(password)).hexdigest()
if user.password == password:
return user
else:
return None
def __str__(self):
return self.email
def __repr__(self):
return str(self.toJSON())
meta = {
'allow_inheritance': True,
'indexes': ['-created', 'email'],
'ordering': ['-created']
}
from project import db
from datetime import datetime
class {{device_class}}Status(db.EmbeddedDocument):
name = db.StringField(max_length=50, unique=True, required=False)
connect = db.BooleanField(required=False)
created_at = db.DateTimeField(default=datetime.utcnow(), required=False)
class {{device_class}}Environment(db.EmbeddedDocument):
{% for sensor in device["device"]["sensors"] %}
{% if sensor == 'temperature' %}
{{sensor}} = db.FloatField(required=False)
{% endif %}
{% if sensor == 'noise' %}
{{sensor}} = db.BooleanField(required=False)
{% endif %}
{% if sensor == 'light' %}
{{sensor}} = db.BooleanField(required=False)
{% endif %}
{% if sensor == 'motion' %}
{{sensor}} = db.BooleanField(required=False)
{% endif %}
{% endfor %}
data_from = db.StringField(max_length=50, required=False)
created_at = db.DateTimeField(default=datetime.utcnow(), required=False)
class {{device_class}}DB(db.Document):
meta = {'collection': '{{device_name}}'}
class PersonDB(db.Document):
meta = {'collection': 'person'}
name = db.StringField(max_length=50, unique=True, required=True)
class Movie(db.Document):
created = db.DateTimeField(default=datetime.datetime.now, required=True)
title = db.StringField(max_length=255, required=True)
summary = db.StringField(max_length=10000, required=True)
tags = db.ListField(db.StringField(max_length=50))
cast = db.ListField(db.StringField())
director = db.StringField()
tmdb_id = db.IntField()
runtime = db.IntField()
poster = db.StringField()
popularity = db.FloatField()
def addTag(self, tag):
if tag not in self.tags:
self.tags.append(tag)
return self
def removeTag(self, tag):
if tag in self.tags:
self.tags.remove(tag)
return self
def getLoan(self, user):
from Loan import Loan
loan = Loan.objects(movie=self, user=user).first()
return loan
def __str__(self):
return self.title
def __repr__(self):
return self.__str__()
def toJSON(self):
import json
return json.dumps({
'created': self.created.isoformat(),
'title': self.title,
'summary': self.summary,
'tags': str(self.tags),
'id': str(self.id)
})
@staticmethod
def convertMovie(movie):
result = Movie()
result.tmdb_id = int(movie.id)
result.title = str(movie.title)
result.summary = str(movie.overview.encode('utf-8'))
if movie.poster:
sizes = movie.poster.sizes()
if len(sizes) > 0:
medium = int(len(sizes) / 2)
result.poster = str(movie.poster.geturl(sizes[medium]))
result.popularity = float(movie.userrating)
result.runtime = int(movie.runtime)
tags = movie.keywords
for tag in tags:
result.addTag(str(tag.name.encode('utf-8')))
genres = movie.genres
for genre in genres:
result.addTag(str(genre.name.encode('utf-8')))
cast = movie.cast
for actor in cast:
result.cast.append("%s:%s" % (actor.name, actor.character))
crew = movie.crew
for person in crew:
job = person.job.encode('utf-8')
if 'director' == job.lower():
result.director = person.name.encode('utf-8')
result.save()
return result
