class Workout(db.Model):
__table__ = db.Table('Workout', db.metadata, autoload=True,
autoload_with=db.engine)
def __init__(self):
self.WorkoutSessionID = None
self.WorkoutDescription = None
def add_workout(self, workout):
self.WorkoutSessionID = workout['workoutSessionID']
self.WorkoutDescription = workout['workoutDescription']
db.session.add(self)
db.session.commit()
return json.dumps(True)
@staticmethod
def get_user_workouts(user_id):
user_workouts = db.session.query(Workout.WorkoutID,
Workout.WorkoutSessionID,
Workout.WorkoutDescription,
Workout.RequestCoachEndorsementDT,
Workout.CoachEndorsementDT,
Workout.EndorsedByUserID).join(
WorkoutSession).filter(
WorkoutSession.UserID == user_id).all()
return jsonify([r._asdict() for r in user_workouts])
class HeartRates(db.Model):
__table__ = db.Table('HeartRates', db.metadata, autoload=True,
autoload_with=db.engine)
def __init__(self):
self.BPM = None
self.HeartRateTypeID = None
self.UserID = None
self.CreateDT = None
def add_heart_rate(self, hr, user_id):
self.BPM = hr['heartRateValue']
self.HeartRateTypeID = hr['heartRateType']
self.UserID = user_id
self.CreateDT = datetime.utcnow()
db.session.add(self)
db.session.commit()
return json.dumps(True)
@staticmethod
def get_user_heart_rates(user_id):
user_heart_rates = db.session.query(HeartRates.HeartRateID,
LKHeartRateType.HeartRateTypeDescription,
HeartRates.BPM,
HeartRates.CreateDT).join(
LKHeartRateType).filter(
HeartRates.UserID == user_id).order_by(
HeartRates.CreateDT.desc()).all()
return jsonify([r._asdict() for r in user_heart_rates])
def make_association_table(fk1, fk2, index=False):
"""Create an association table basing on names of two given foreign keys.
From keys: `site.id` and `kinase.id` a table named: site_kinase_association
will be created and it will contain two columns: `site_id` and `kinase_id`.
The foreign keys can be provided as models properties, e.g. Model.id,
or as SQL strings, e.g. 'model.id'.
"""
if not isinstance(fk1, str):
fk1 = f'{fk1.table}.{fk1.name}'
if not isinstance(fk2, str):
fk2 = f'{fk2.table}.{fk2.name}'
fk1_table = fk1.split('.')[0]
fk2_table = fk2.split('.')[0]
table_name = f'{fk1_table}_{fk2_table}_association'
col1 = fk1.replace('.', '_')
col2 = fk2.replace('.', '_')
table_args = [
table_name,
db.metadata,
db.Column(col1, db.Integer, db.ForeignKey(fk1,
ondelete='cascade')),
db.Column(col2, db.Integer, db.ForeignKey(fk2,
ondelete='cascade')),
]
if index:
table_args.append(db.Index(f'idx_{col1}_{col2}', col1, col2))
return db.Table(*table_args, info={'bind_key': bind})
class LKUserType(db.Model):
__table__ = db.Table('LKUserType', db.metadata, autoload=True,
autoload_with=db.engine)
@staticmethod
def get_user_types():
user_types = db.session.query.order_by(LKUserType.UserTypeID)
return user_types
class Users(db.Model):
__table__ = db.Table('Users', db.metadata, autoload=True,
autoload_with=db.engine)
def __init__(self):
"""init method to declare variables used in Users class.
"""
self.UserTypeID = None
self.FirstName = None
self.LastName = None
self.Email = None
self.Salt = None
self.Password = None
def add_user(self, new_user):
"""Create a new user in the database.
new_user is a JSON object pulled in from the front end.
"""
self.UserTypeID = new_user['userTypeID']
self.FirstName = new_user['firstName']
self.LastName = new_user['lastName']
self.Email = new_user['email']
password = new_user['password']
self.Salt = create_salt()
self.Password = hashlib.sha512(password + self.Salt).hexdigest()
try:
db.session.add(self)
db.session.commit()
except Exception as e:
return_value = "Failed to add new user, please try again later"
# logger.exception(e)
else:
return_value = "Success"
return return_value
# user being passed in here is user data from the form
@staticmethod
def get_user_id(user):
# accessing the email of that user from form
user_email = user['email']
check_user = db.session.query(Users.UserID, Users.Salt,
Users.Password).filter(
Users.Email == user_email).first()
if check_user is None:
# when returning bools, change to json.dumps(bool)
return json.dumps(False)
hashed_pw = hashlib.sha512(user['password'] +
check_user.Salt).hexdigest()
if hashed_pw == check_user.Password:
return check_user.UserID
else:
return json.dumps(False)
class LKWorkoutSessionType(db.Model):
__table__ = db.Table('LKWorkoutSessionType', db.metadata, autoload=True,
autoload_with=db.engine)
@staticmethod
def get_workout_session_types_json(user_id=0):
user_type = db.session.query(Users.UserTypeID).filter(Users.UserID ==
user_id).one()
workout_session_types = db.session.query(
LKWorkoutSessionType.WorkoutSessionTypeID,
LKWorkoutSessionType.WorkoutSessionTypeDescription).filter(
or_(LKWorkoutSessionType.UserType == user_type[0],
user_type[0] == 0, LKWorkoutSessionType.UserType == None)
).order_by(LKWorkoutSessionType.WorkoutSessionTypeID).all()
return jsonify([r._asdict() for r in workout_session_types])
class WorkoutSession(db.Model):
__table__ = db.Table('WorkoutSession', db.metadata, autoload=True,
autoload_with=db.engine)
def __init__(self):
self.WorkoutSessionTypeID = None
self.UserID = None
self.WorkoutSessionDescription = None
self.CreateDT = None
def add_workout_session(self, workout_session, user_id):
self.WorkoutSessionTypeID = workout_session['workoutSessionTypeID']
self.UserID = user_id
self.WorkoutSessionDescription = workout_session[
'workoutSessionDescription']
self.CreateDT = datetime.utcnow()
db.session.add(self)
db.session.commit()
return json.dumps(True)
@staticmethod
def get_user_workout_sessions(user_id):
user_workout_sessions = db.session.query(
WorkoutSession.WorkoutSessionID,
WorkoutSession.WorkoutSessionTypeID,
WorkoutSession.WorkoutSessionDescription,
WorkoutSession.CreateDT,
LKWorkoutSessionType.WorkoutSessionTypeDescription
).join(LKWorkoutSessionType).filter(WorkoutSession.UserID ==
user_id).all()
return jsonify([r._asdict() for r in user_workout_sessions])
@staticmethod
def check_user_workout_session(user_id, workout_session_id):
user_workout_session = db.session.query(
WorkoutSession.WorkoutSessionID).filter(WorkoutSession.UserID ==
user_id).filter(
WorkoutSession.WorkoutSessionID == workout_session_id).all()
if user_workout_session > 0:
return_value = True
else:
return_value = False
return return_value
class LKHeartRateType(db.Model):
__table__ = db.Table('LKHeartRateType', db.metadata, autoload=True,
autoload_with=db.engine)
@staticmethod
def get_heart_rate_types_json():
hr_types = db.session.query(LKHeartRateType.HeartRateTypeID,
LKHeartRateType.HeartRateTypeDescription).order_by(
LKHeartRateType.HeartRateTypeID).all()
return jsonify([r._asdict() for r in hr_types])
@staticmethod
def add_heart_rate(hr, user_id):
bpm = hr['heartRateValue']
heart_rate_type_id = hr['heartRateType']
heart_rate = HeartRates(HeartRateTypeID=heart_rate_type_id, BPM=bpm,
UserID=user_id, CreateDT=datetime.utcnow())
db.session.add(heart_rate)
db.session.commit()
return json.dumps(True)
class Notes(db.Model):
__table__ = db.Table('Notes', db.metadata, autoload=True,
autoload_with=db.engine)
def __init__(self):
self.NoteID = None
self.SystemAreaTypeID = None
self.SystemAreaID = None
self.NoteContent = None
self.CreatedByUserID = None
self.ForUserID = None
self.CreateDT = None
def add_note(self, user_id, system_area_type_id, note_details):
self.SystemAreaTypeID = system_area_type_id
self.SystemAreaID = note_details['systemAreaID']
self.CreatedByUserID = user_id
if note_details['forUserID'] == 0:
note_details['forUserID'] = user_id
self.ForUserID = note_details['forUserID']
self.CreateDT = datetime.utcnow()
self.NoteContent = note_details['noteContent']
db.session.add(self)
db.session.commit()
return json.dumps(True)
@staticmethod
def get_notes(user_id, system_area_type_id, system_area_id):
notes = db.session.query(
Notes.NoteID,
Notes.SystemAreaTypeID,
Notes.SystemAreaID,
Notes.NoteContent,
Notes.CreateDT,
Users.FirstName,
Users.LastName
).join(Users, Users.UserID == Notes.CreatedByUserID).filter(
Notes.ForUserID == user_id).filter(Notes.SystemAreaTypeID ==
system_area_type_id).filter(
Notes.SystemAreaID == system_area_id).all()
return jsonify([r._asdict() for r in notes])
"""
Association class used to hold the positions of cells in a task
"""
__tablename__ = 'nbgen_taskcells'
task_id = db.Column(db.Integer,
db.ForeignKey('nbgen_tasks.id'),
primary_key=True)
cell_id = db.Column(db.Integer,
db.ForeignKey('nbgen_cells.id'),
primary_key=True)
position = db.Column(db.Integer)
cell = db.relationship('Cell')
option_tasks = db.Table(
'nbgen_task_association',
db.Column('option_id', db.Integer, db.ForeignKey('nbgen_orderoptions.id')),
db.Column('task_id', db.Integer, db.ForeignKey('nbgen_tasks.id')))
template_tasks = db.Table(
'nbgen_template_tasks',
db.Column('notebook_id', db.Integer,
db.ForeignKey('nbgen_nbtemplates.id')),
db.Column('task_id', db.Integer, db.ForeignKey('nbgen_tasks.id')))
class NotebookFile(db.Model):
__tablename__ = 'nbgen_files'
id = db.Column(db.Integer, primary_key=True)
category = db.Column(db.Integer, nullable=False)
filename = db.Column(db.Text, nullable=False)
hash = db.Column(db.Text, nullable=False)
from uuid import uuid4
from sqlalchemy import func
from app.domains.providers import NullOrNoneValueException
from database import db
from app.domains.providers.emails.emails import Email
from app.domains.providers.cnpj_model.cnpj_model import CNPJModel
from app.domains.providers.telephone.telephone import Telephone
provider_category = db.Table(
'provider_category',
db.Column('provider_id',
db.String(36),
db.ForeignKey("provider.id"),
primary_key=True),
db.Column('category_id',
db.String(36),
db.ForeignKey("category.id"),
primary_key=True),
)
class Provider(db.Model):
__tablename__ = 'provider'
id = db.Column(db.String(36),
primary_key=True,
default=lambda: str(uuid4()))
name = db.Column(db.String(80))
fantasy_name = db.Column(db.String(80), unique=True)
email = db.Column(db.String(120))
cnpj = db.Column(db.String(18), unique=True)
from database import db
tags_relations = db.Table(
'tags_relations',
db.Column('tag_id', db.Integer, db.ForeignKey('tag.id'), primary_key=True),
db.Column('application_id',
db.Integer,
db.ForeignKey('application.id'),
primary_key=True))
from database import db
from datetime import datetime
tags = db.Table(
'tags',
db.Column('tag_id', db.Integer, db.ForeignKey('tag.id'), primary_key=True),
db.Column('post_id',
db.Integer,
db.ForeignKey('post.id'),
primary_key=True))
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), nullable=False)
body = db.Column(db.Text, nullable=False)
pub_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
author = db.Column(db.String(80), nullable=False)
tags = db.relationship('Tag',
secondary=tags,
lazy='subquery',
backref=db.backref('posts', lazy=True))
category_id = db.Column(db.Integer,
db.ForeignKey('category.id'),
nullable=False)
category = db.relationship('Category',
backref=db.backref('posts', lazy=True))
def __init__(self, title, body, category, pub_date=None):
self.title = title
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String)
analyses = db.relationship('Analysis',backref='owner',lazy='dynamic')
class Analysis(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String)
runcondition_id = db.Column(db.Integer,db.ForeignKey('run_condition.id'))
owner_id = db.Column(db.Integer,db.ForeignKey('user.id'))
requests = db.relationship('Request',backref='analysis',lazy='dynamic')
subscriptions = db.Table('subscriptions',
db.Column('subscriber_id',db.Integer,db.ForeignKey('user.id')),
db.Column('reqeust_id',db.Integer,db.ForeignKey('request.id'))
)
class Request(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String)
analysis_id = db.Column(db.Integer,db.ForeignKey('analysis.id'))
responses = db.relationship('Response', backref='request', lazy = 'dynamic')
parameter_points = db.relationship('ParameterPoint',backref = 'request',lazy='dynamic')
subscribers = db.relationship('User',secondary=subscriptions)
class ParameterPoint(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String)
from database import db
from flask_login import UserMixin
from login.login_manager import login_manager
users_roles = db.Table('users_roles',
db.Column('user_id', db.Integer(), db.ForeignKey('users.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('roles.id')))
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
def __init__(self, name, description):
self.name = name
self.description = description
def __repr__(self):
return '<Role %r>' % self.id
def save(self):
db.session.add(self)
db.session.commit()
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
name = db.Column(db.String(255))
jobTitle = db.Column(db.String(80))
nullable=False)
data_source = db.relationship('DataSource', backref='data', lazy=True)
data_range_id = db.Column(db.Integer, db.ForeignKey('data_range.id'))
data_range = db.relationship('DataRange', backref='data', lazy=True)
timestamp = db.Column(db.DateTime)
value = db.Column(db.Text, nullable=False)
def __repr__(self):
return '<Data %r>' % self.id
data_source_dependencies = db.Table(
'data_source_dependencies',
db.Column('data_source_id',
db.Integer,
db.ForeignKey('data_source.id'),
primary_key=True),
db.Column('data_source_dependency_id',
db.Integer,
db.ForeignKey('data_source.id'),
primary_key=True))
class DataSource(db.Model):
__tablename__ = 'data_source'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
description = db.Column(db.Text, nullable=False)
dependencies = db.relationship(
'DataSource',
secondary=data_source_dependencies,
primaryjoin=id == data_source_dependencies.c.data_source_id,
self.processor_id = None
@property
def approved(self):
if self.result is None:
return None
else:
return bool(self.result)
@approved.setter
def approved(self, result):
self.result = int(result)
def __repr__(self):
return u'<Applicant id={0:d}, user={1!r}, reason={2}>'.format(
self.id, self.user, self.reason)
LastRead = db.Table(
'last_read',
db.Column('user_id',
db.Integer,
db.ForeignKey('user.id'),
primary_key=True),
db.Column('thread_id',
db.Integer,
db.ForeignKey('thread.id'),
primary_key=True),
db.Column('post_number', db.Integer, db.ForeignKey('post.number')),
db.Index('user_thread_index', 'user_id', 'thread_id'))
""" Models for session and user data. See users. module for user
progression.
"""
from database import db
from sqlalchemy import UniqueConstraint
from sqlalchemy.orm import validates
__all__ = ['Session', 'User']
user_sessions = db.Table(
'user_sessions',
db.Column('session_id', db.Integer, db.ForeignKey('session.id')),
db.Column('user_id', db.Integer, db.ForeignKey('user.id')))
class Session(db.Model):
__tablename__ = 'session'
id = db.Column(db.Integer, primary_key=True)
access_token = db.Column(db.String(64), unique=True)
inet_addr = db.Column(db.Text)
def __repr__(self):
return "<Session %d / %s>" % (self.id, self.access_token)
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
# Username will probably just be an email
username = db.Column(db.Text)
from werkzeug.security import check_password_hash, generate_password_hash
from database import db
from database.MainModel import MainModel
user_permission = db.Table(
'user_permission',
db.Column('user_id', db.Integer, db.ForeignKey(
'user.id', ondelete='CASCADE'), comment='用户编号'),
db.Column('permission_id', db.Integer, db.ForeignKey(
'permission.id', ondelete='CASCADE'), comment='操作权限编号'),
comment='用户操作权限',
)
user_role = db.Table(
'user_role',
db.Column('user_id', db.Integer, db.ForeignKey(
'user.id', ondelete='CASCADE'), comment='用户编号'),
db.Column('role_id', db.Integer, db.ForeignKey(
'role.id', ondelete='CASCADE'), comment='角色编号'),
comment='用户角色',
)
# 用户管理
class User(db.Model, MainModel):
__tablename__ = 'user'
__table_args__ = {'comment': '用户'}
# __permission__ = {}
username = db.Column(db.String(20), unique=True,
nullable=False, comment='用户名', )
from database import db
from sqlalchemy import ForeignKey
from sqlalchemy_utils.types.password import PasswordType
import datetime
tags = db.Table(
'tags',
db.Column('tag_id', db.Integer, db.ForeignKey('tag.id'), primary_key=True),
db.Column('event_id',
db.Integer,
db.ForeignKey('event.id'),
primary_key=True))
backers = db.Table(
'backers', db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
db.Column('event_id', db.Integer, db.ForeignKey('event.id')),
db.Column('backed_amount', db.Float()))
watchers = db.Table(
'watchers', db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
db.Column('event_id', db.Integer, db.ForeignKey('event.id')))
class VotedTest(db.Model):
__tablename__ = "votedtest"
event_id = db.Column(db.Integer, ForeignKey('event.id'), primary_key=True)
user_id = db.Column(db.Integer, ForeignKey('user.id'), primary_key=True)
stars = db.Column(db.Integer())
votes = db.relationship("Event", back_populates="votes")
voted = db.relationship("User", back_populates="voted")
from database import db
from flask_security import UserMixin, RoleMixin, SQLAlchemyUserDatastore
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 User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=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())
roles = db.relationship('Role', secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(255))
current_login_ip = db.Column(db.String(255))
login_count = db.Column(db.Integer)
def __repr__(self):
return '<models.User[email=%s]>' % self.email
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
id = db.Column('category',
db.Integer,
db.Sequence('categories_category_seq'),
primary_key=True,
server_default=db.FetchedValue())
categoryname = db.Column(db.String(50), nullable=False)
def __repr__(self):
return self.categoryname
t_cust_hist = db.Table(
'cust_hist',
db.Column('customerid',
db.ForeignKey('customers.customerid', ondelete='CASCADE'),
nullable=False,
index=True), db.Column('orderid', db.Integer, nullable=False),
db.Column('prod_id', db.Integer, nullable=False))
class Customer(db.Model):
__tablename__ = 'customers'
id = db.Column('customerid',
db.Integer,
db.Sequence('customers_customerid_seq'),
primary_key=True,
server_default=db.FetchedValue())
firstname = db.Column(db.String(50), nullable=False)
lastname = db.Column(db.String(50), nullable=False)
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key = True)
name = db.Column(db.Unicode(32), unique = True)
description = db.Column(db.Text)
def __init__(self, name, description):
self.name = name
self.description = description
def __repr__(self):
return '<Role %r>' % self.name
user_roles = db.Table('user_roles',
db.Column('role_id', db.Integer, db.ForeignKey('roles.id')),
db.Column('user_id', db.String(32), db.ForeignKey('users.id'))
)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.String(40), primary_key = True) # UUID
email = db.Column(db.String(32), index=True, unique=True)
name = db.Column(db.Unicode(64))
password_hash = db.Column(db.String(128))
roles = db.relationship('Role', secondary=user_roles,
backref=db.backref('users', lazy='dynamic'))
organization = db.Column(db.Unicode(128), nullable=True)
scans = db.relationship("Scan", back_populates="user")
domains = db.relationship("Domain", back_populates="user")
num_domains = db.Column(db.Integer)
num_scans = db.Column(db.Integer)
from database import db
# Stores skills for candidates
candidate_skills = db.Table(
'candidate_skills',
db.Column('candidate_id', db.Integer,
db.ForeignKey('candidate.candidate_id')),
db.Column('skill_id', db.Integer, db.ForeignKey('skill.skill_id')),
)
# Stores skills for jobs
job_skills = db.Table(
'job_skills', db.Column('job_id', db.Integer, db.ForeignKey('job.job_id')),
db.Column('skill_id', db.Integer, db.ForeignKey('skill.skill_id')))
name='_morphophon_uc'), )
def __repr__(self):
attrs = [
self.stem, self.wordclass, self.diphthong, self.gradation,
self.rime, self.soggi
]
S = unicode('/'.join([a for a in attrs if a.strip()])).encode('utf-8')
return "<Morphophon: %s>" % S
# Many-To-Many intermediary table
""" This foreignkey relationship is for concepts and semantic types. """
concept_semtype = db.Table(
'concept_semtype',
db.Column('concept_id', db.Integer, db.ForeignKey('concept.id')),
db.Column('semtype_id', db.Integer, db.ForeignKey('semtype.id')))
# Many-To-Many intermediary table
""" This foreignkey relationship is for concepts and sources. """
concept_source = db.Table(
'concept_source',
db.Column('concept_id', db.Integer, db.ForeignKey('concept.id')),
db.Column('source_id', db.Integer, db.ForeignKey('source.id')))
# Many-To-Many intermediary table
concept_dialect = db.Table(
'concept_dialect',
db.Column('concept_id', db.Integer, db.ForeignKey('concept.id')),
db.Column('dialect_id', db.Integer, db.ForeignKey('dialect.id')))
""" This relationship is at the heart of the concept-to-media
""" Testbed experiment-related functionality. """
from datetime import datetime
from enum import Enum
from database import db, DatabaseEnum
experimentHistory = db.Table(
'experiment_history',
db.Column('experiment_id', db.Integer, db.ForeignKey('experiment.id')),
db.Column('node_id', db.Integer, db.ForeignKey('node.id')))
class Experiment(db.Model):
"""
Represents a testbed experiment.
"""
__table_args__ = {'sqlite_autoincrement': True}
Status = Enum("Status", "PREPARING RUNNING FINISHED")
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50))
status = db.Column(DatabaseEnum(Status, *[e.name for e in Status]))
overlay = db.Column(db.String(50))
creationTime = db.Column(db.DateTime)
startTime = db.Column(db.DateTime)
finishTime = db.Column(db.DateTime)
nodes = db.relationship("Node", secondary=experimentHistory, \
backref=db.backref("experiments", lazy="dynamic"), lazy="dynamic")
from database import db
product_tag_link = db.Table(
'product_tag_link',
db.Column('product_id', db.Integer, db.ForeignKey('product.id')),
db.Column('tag', db.Integer, db.ForeignKey('tag.value')))
app_tag_link = db.Table(
'app_tag_link',
db.Column('app_id', db.Integer, db.ForeignKey('application.id')),
db.Column('tag', db.Integer, db.ForeignKey('tag.value')))
def __init__(self, name=None):
'''
name - Team name
'''
self.name = name
def to_json(self):
return dict(type='teams', id=self.id, name=self.name)
def __repr__(self):
return '<Team {0}>'.format(self.name)
teams = db.Table('users_to_teams',
db.Column('user_id', db.Integer, db.ForeignKey('users.id')),
db.Column('team_id', db.Integer, db.ForeignKey('teams.id')))
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(256), unique=True)
name = db.Column(db.String(256))
primary_team = db.Column(db.Integer,
db.ForeignKey('teams.id'),
nullable=True)
contact_card = db.Column(db.Text())
api_key = db.Column(db.String(256))
# Not sure why I had this??
from database import db
todo_item_tags = db.Table('todo_item_tags',
db.Column('id', db.Boolean),
db.Column('todo_item_id', db.Integer, db.ForeignKey('todo_item.id')),
db.Column('tag_id', db.Integer, db.ForeignKey('tag.id')),
)
class Tag(db.Model):
__tablename__ = 'tag'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(255), nullable=False)
todo_items = db.relationship('TodoItem', back_populates="tags", secondary=todo_item_tags)
def serialize(self):
return {
'id': self.id,
'name': self.name,
}
from flask import Flask
from sqlalchemy import Table, Column, Integer, ForeignKey
from sqlalchemy.orm import relationship, backref
from flask.ext.sqlalchemy import *
import os
from database import db
# many to many associations
company_investors_association = db.Table(
'company_investor_association',
db.Column('company_id', db.Integer, db.ForeignKey('company.id')),
db.Column('person_id', db.Integer, db.ForeignKey('person.id')))
company_tags_association = db.Table(
'company_tags_association',
db.Column('company_id', db.Integer, db.ForeignKey('company.id')),
db.Column('tag_id', db.Integer, db.ForeignKey('tag.id')))
company_employees_association = db.Table(
'company_employees_association',
db.Column('company_id', db.Integer, db.ForeignKey('company.id')),
db.Column('person_id', db.Integer, db.ForeignKey('person.id')))
company_milestones_association = db.Table(
'company_milestones_association',
db.Column('company_id', db.Integer, db.ForeignKey('company.id')),
db.Column('miletstone_id', db.Integer, db.ForeignKey('milestone.id')))
company_competitors_association = db.Table(
'company_competitors_association',
