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