class CommentModel(db.Model):
__tablename__ = 'comments'
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text, nullable=False)
created_date = db.Column(db.DateTime, default=datetime.now)
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
post_id = db.Column(db.Integer, db.ForeignKey('posts.id'))
likes = db.relationship('LikeModel', cascade='all,delete', backref='comment')
@classmethod
def find_by_id(cls, comment_id):
return cls.query.filter_by(id=comment_id).first()
def verify_comment_author(self, user_id):
if user_id == self.author_id:
return True
else:
return False
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class Approval(db.Model):
__tablename__ = "approval_status"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
def __init__(self, name):
self.name = name
class Direction(db.Model):
__tablename__ = "direction"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
def __init__(self, name, code):
self.name = name
class Quad(db.Model):
__tablename__ = "quad"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
def __init__(self, name):
self.name = name
class Ethnicity(db.Model):
__tablename__ = "ethnicity"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
code = db.Column(db.String(64), nullable=False)
continent_id = db.relationship('continent_id',
backref='continent',
uselist=False)
class Owner(db.Model):
__tablename__ = "owners"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
pet = db.relationship('Pet', backref='owner', uselist=False)
def __init__(self, name):
self.name = name
class ProductCode(db.Model):
__tablename__ = "product_code"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
pcode = db.Column(db.String(64), nullable=False)
def __init__(self, name, pcode):
self.name = name
self.pcode = pcode
class Catalog(db.Model):
__tablename__ = "catalog_detail"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
pcode = db.relationship('pcode', backref='product_code', uselist=False)
def __init__(self, pcode, name):
self.pcode = pcode
self.name = name
class Pet(db.Model):
__tablename__ = 'pets'
id = db.Column(db.Integer, primary_key = True)
owner_id = db.Column(db.Integer, db.ForeignKey('owners.id'))
name = db.Column(db.String(100), nullable=False)
def __init__(self, owner_id, name):
self. owner_id = owner_id
self.name = name
class FeatureType(db.Model):
__tablename__ = "feature_types"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
code = db.Column(db.String(64), nullable=False)
feature = db.relationship('Feature', backref='feature', uselist=False)
def __init__(self, name, code):
self.name = name
self.code = code
class Continent(db.Model):
__tablename__ = "continents"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
code = db.Column(db.String(64), nullable=False)
ethnicity = db.relationship('Ethnicity',
backref='continent',
uselist=False)
def __init__(self, name, code):
self.name = name
self.code = code
class Ethnicity(db.Model):
__tablename__ = 'ethnicitys'
id = db.Column(db.Integer, primary_key=True, nullable=False)
continent_id = db.Column(db.Integer,
db.ForeignKey('continents.id'),
nullable=False)
name = db.Column(db.String(100), nullable=False)
code = db.Column(db.String(100), nullable=False)
#feature = db.relationship('Feature', backref='ethnicity', uselist=False)
def __init__(self, continent_id, name, code):
self.continent_id = continent_id
self.name = name
self.code = code
class Feature(db.Model):
__tablename__ = "feature"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
ethnicity_id = db.relationship('ethnicity_id',
backref='ethnicity',
uselist=False)
approval_status_id = db.relationship('approval_status_id',
backref='approval_status',
uselist=False)
feature_type_id = db.relationship('feature_type_id',
backref='feature_type',
uselist=False)
direction_id = db.relationship('direction_id',
backref='direction',
uselist=False)
map_id = db.relationship('map_id', backref='map', uselist=False)
class LikeModel(db.Model):
__tablename__ = 'likes'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
comment_id = db.Column(db.Integer, db.ForeignKey('comments.id'))
@classmethod
def find(cls, user_id, comment_id):
return cls.query.filter_by(user_id=user_id, comment_id=comment_id).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class User(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.Unicode(255), unique=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
created_at = db.Column(db.DateTime(), default=datetime.utcnow)
models = db.relationship('Model')
roles = db.relationship('Role', secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120), nullable=False, unique=True)
email = db.Column(db.String(120), nullable=False, unique=True)
name = db.Column(db.String(150), nullable=False)
password = db.Column(db.String(100), nullable=False)
posts = db.relationship('PostModel',
cascade='all,delete',
backref='author')
comments = db.relationship('CommentModel',
cascade='all,delete',
backref='author')
likes = db.relationship('LikeModel', cascade='all,delete', backref='user')
activated = db.Column(db.Boolean, default=False)
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def find_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def find_by_id(cls, user_id):
return cls.query.filter_by(id=user_id).first()
@classmethod
def set_password(cls, password):
return password_hasher.hash(password)
def send_confirmation_email(self):
link = request.url_root[:-1] + url_for(
'resources.users.activate_account', user_id=self.id)
subject = 'Account Confirmation'
text = f"Please click the link to register: {link}"
html = f'<html>Please click the link to register: <a href="{link}"> {link}</a></html>'
return Mailer.send(self.email, subject, text, html)
def verify_password(self, password):
return password_hasher.verify(self.password, password)
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class Continent(db.Model):
__tablename__ = "continent"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
code = db.Column(db.String(64), nullable=False)
class Role(db.Model, RoleMixin):
__tablename__ = 'role'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.Unicode(80), unique=True)
description = db.Column(db.Unicode(255))
class Quad(db.Model):
__tablename__ = "quad"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
class Model(db.Model):
__tablename__ = 'model'
query_class = ModelQuery
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.Unicode(255), unique=True)
description = db.Column(db.Unicode())
owner = db.relationship('User')
owner_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
created_at = db.Column(db.DateTime(), default=datetime.utcnow)
updated_at = db.Column(db.DateTime(), default=datetime.utcnow)
search_vector = db.Column(TSVectorType('name', 'description'))
def __init__(self, name):
self.name = name
@property
def repo_path(self):
return path.join(current_app.config['REPO_DIR'], self.name)
@property
def archive_path(self):
return path.join(current_app.config['ARCHIVE_DIR'], self.name)
@property
def meta_path(self):
return path.join(self.repo_path, 'meta.json')
@property
def model_path(self):
return path.join(self.repo_path, 'model.json')
@property
def repo(self):
return Repo(self.repo_path) if path.exists(self.repo_path) else None
def register(self, user):
"""registers the model to the specified user"""
self.owner = user
if self.repo is None:
self.make_repo()
def archive(self, version=None):
"""returns path for a specific version's archive.
if version is None, returns latest version"""
if self.repo is None:
raise ModelNotFoundException
if version is None:
version = self.latest
if version not in self.versions:
raise ModelNotFoundException
return path.join(self.archive_path, '{}.tar'.format(version))
def make_repo(self):
"""creates a new git repo for the model,
if it doesn't already exist"""
if path.exists(self.repo_path):
raise ModelConflictException
Repo.init(self.repo_path)
@property
def latest(self):
"""returns the latest version"""
if not self.versions:
return None
return self.versions[-1]
@property
def versions(self):
"""all available versions"""
repo = self.repo
if repo is None or not repo.tags:
return []
return [tag.name for tag in repo.tags]
def publish(self, meta_data, model_data, version):
"""updates a repo for the model (publishes a new version)"""
repo = self.repo
if repo is None:
raise ModelNotFoundException
# the new version must be the newest
if self.latest is not None and LooseVersion(self.latest) >= LooseVersion(version):
raise ModelConflictException('Published version must be newer than {}'.format(self.latest))
with open(self.meta_path, 'w') as f:
json.dump(meta_data, f)
# TODO this should be PMML or something
with open(self.model_path, 'w') as f:
json.dump(model_data, f)
repo.index.add(['*'])
author = Actor(self.owner.name, self.owner.email)
repo.index.commit(version, author=author, committer=author)
repo.create_tag(version)
self.description = meta_data.get('description', '')
self.updated_at = datetime.utcnow()
def make_archive(self, version):
"""creates a tar archive for a specific version of the model"""
if not path.exists(self.archive_path):
makedirs(self.archive_path)
self.repo.archive(open(self.archive(version), 'wb'), version)
def delete(self, version):
"""deletes a specific version"""
if version not in self.versions:
raise ModelNotFoundException
remove(self.archive(version))
self.repo.delete_tag(version)
def destroy(self):
"""destroys the entire package"""
shutil.rmtree(self.repo_path)
shutil.rmtree(self.archive_path)
@property
def meta(self):
"""model metadata"""
return json.load(open(self.meta_path, 'r'))
class ProductCode(db.Model):
__tablename__ = "product_code"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
pcode = db.Column(db.String(64), nullable=False)
class FeatureType(db.Model):
__tablename__ = "feature_type"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
code = db.Column(db.String(64), nullable=False)
class Direction(db.Model):
__tablename__ = "direction"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
from lib.db import db
from datetime import datetime
from flask_security import UserMixin, RoleMixin
# Table connecting users and roles
roles_users = db.Table('roles_users',
db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))
class Role(db.Model, RoleMixin):
__tablename__ = 'role'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.Unicode(80), unique=True)
description = db.Column(db.Unicode(255))
class User(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.Unicode(255), unique=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
created_at = db.Column(db.DateTime(), default=datetime.utcnow)
models = db.relationship('Model')
roles = db.relationship('Role', secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
class Feature(db.Model):
__tablename__ = "features"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
latitude = db.Column(db.Integer, nullable=False)
longitude = db.Column(db.Integer, nullable=False)
starting_latitude = db.Column(db.Integer, nullable=False)
ending_latitude = db.Column(db.Integer, nullable=False)
starting_longitude = db.Column(db.Integer, nullable=False)
ending_longitude = db.Column(db.Integer, nullable=False)
direction_id = db.Column(db.Integer, db.ForeignKey('direction.id'))
diameter = db.Column(db.Integer, nullable=False)
ethnicity_id = db.Column(db.Integer, db.ForeignKey('ethnicity.id'))
quad_id = db.Column(db.Integer, db.ForeignKey('quad.id'))
map_id = db.Column(db.Integer, db.ForeignKey('map.id'))
approval_status_id = db.Column(db.Integer,
db.ForeignKey('approval_status.id'))
approval_date = db.Column(db.DateTime, nullable=False)
ref = db.Column(db.Integer, nullable=False)
reference_text = db.Column(db.String(64), nullable=False)
feature_type_id = db.Column(db.Integer, db.ForeignKey('feature_type.id'))
origin = db.Column(db.String(64), nullable=False)
location = db.Column(db.String(64), nullable=False)
circle_area = db.Column(db.Integer, nullable=False)
square_area = db.Column(db.Integer, nullable=False)
circle_area_mod = db.Column(db.Integer, nullable=False)
def __init__(self, name, latitude, longitude, starting_latitude,
ending_latitude, starting_longitude, ending_longitude,
direction_id, diameter, ethnicity_id, quad_id, map_id,
approval_status_id, approval_date, ref, reference_text,
feature_type_id, origin, location, circle_area, square_area,
circle_area_mod):
name = name
latitude = latitude
longitude = longitude
starting_latitude = starting_latitude
ending_latitude = ending_latitude
starting_longitude = starting_longitude
ending_longitude = ending_longitude
direction_id = direction_id
diameter = diameter
ethnicity_id = ethnicity_id
quad_id = quad_id
map_id = map_id
approval_status_id = approval_status_id
approval_date = approval_date
ref = ref
reference_text = reference_text
feature_type_id = feature_type_id
origin = origin
location = location
circle_area = circle_area
square_area = square_area
circle_area_mod = circle_area_mod
