class Deck(Base):
__tablename__ = 'decks'
name = db.Column(db.String(128))
format = db.Column(db.String(128), nullable=False)
cards = db.relationship('DeckCard', back_populates='deck')
def count_cards(self):
count = 0
for card in self.cards:
count += card.qty_main + card.qty_sideboard
return count
def count_main(self):
count = 0
for card in self.cards:
count += card.qty_main
return count
def count_sideboard(self):
count = 0
for card in self.cards:
count += card.qty_sideboard
return count
class User(db.Model):
id = db.Column("id", db.Integer, primary_key=True)
firstname = db.Column("firstname", db.String(100))
lastname = db.Column("lastname", db.String(100))
email = db.Column("email", db.String(100))
password = db.Column(db.String(255), nullable=False)
registered_on = db.Column(db.DateTime, nullable=False)
notes = db.relationship("Note", backref="user", lazy=True)
comments = db.relationship("Comment", backref="user", lazy=True)
def __init__(self, firstname, lastname, email, password):
self.firstname = firstname
self.lastname = lastname
self.email = email
self.password = password
self.registered_on = datetime.date.today()
class ContinuousResourceAllocation(db.Model):
__tablename__ = "continuous_resource_allocations"
# Ids
id = db.Column(db.String(36), primary_key=True, unique=True)
# Parents
resource_id = db.Column(db.ForeignKey('continuous_resources.id'))
resource = db.relationship('ContinuousResource', foreign_keys=resource_id)
# Attributes
resource_type = db.Column(db.String(36), primary_key=True)
created = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.utcnow)
from_infinity = db.Column(db.Boolean, default=False)
to_infinity = db.Column(db.Boolean, default=False)
from_datetime = db.Column(db.DateTime, nullable=True)
to_datetime = db.Column(db.DateTime, nullable=True)
allocation_type = db.Column(db.String(20))
description = db.Column(db.String(100), nullable=True)
json_dump = db.Column(db.String(200), nullable=True)
@property
def dump(self) -> dict:
try:
return json.loads(self.json_dump)
except:
return {}
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(24), unique=True)
display_name = db.Column(db.String(50), unique=True)
password = db.Column(db.String(50))
avatar = db.Column(db.String(50))
email = db.Column(db.String(100))
timezone = db.Column(db.String(30))
token = db.Column(db.String(50))
approved = db.Column(db.Boolean())
posts = db.relationship('Post', backref='author', lazy='dynamic')
def is_authenticated(self):
return True
def is_active(self):
return bool(self.approved)
def is_anonymous(self):
return not self.approved
def get_id(self):
return unicode(self.id)
def get_auth_token(self):
return make_secure_token(self.name, self.password)
def __repr__(self):
return u"<User: id={0:>s}, name={1:>s}, display_name={2:>s}, email={3:>s}, approved={4!r}>".format(
str(self.id), self.name, self.display_name, self.email,
bool(self.approved))
class Company(db.Model):
__tablename__ = "company"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
tags = db.relationship("Tag", secondary=company_tags_association)
number_of_employees = db.Column(Integer)
founded_year = db.Column(Integer(4))
founded_month = db.Column(db.Integer)
founded_day = db.Column(db.Integer)
image = db.Column(db.String)
milestones = db.relationship("Milestone",
secondary=company_milestones_association)
crunchbase_url = db.Column(db.String)
homepage_url = db.Column(db.String)
# startup or finanical organization
company_type = db.Column(db.String)
class Category(db.Model):
__tablename__ = 'category'
id = db.Column(db.String(36),
primary_key=True,
default=lambda: str(uuid4()))
name = db.Column(db.String(80))
profit_percent = db.Column(db.Float(2), default=0.0)
created_at = db.Column(db.DateTime(timezone=True), default=func.now())
updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
is_active = db.Column(db.Boolean, unique=False, default=True)
deleted_at = db.Column(db.DateTime(timezone=True), default=None)
product_line = db.relationship('ProductLine', backref='product_line')
def __init__(self, **kwargs):
super().__init__(**kwargs)
for keys in kwargs:
if keys == 'id' or keys == 'name':
if kwargs[keys] is None or kwargs[keys] == '':
raise NullOrNoneValueException(f'The {keys} is empty')
def serialize(self) -> dict:
return {
"id": self.id,
"name": self.name,
"profit_percent": self.profit_percent,
"created_at": self.created_at,
"updated_at": self.updated_at,
"is_active": self.is_active,
"deleted_at": self.deleted_at
}
class Resource(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
preset = db.Column(db.Boolean())
roles = db.relationship('Role',
secondary=roles_resources,
backref=db.backref('resources', lazy='dynamic'))
def __str__(self):
return self.name
@classmethod
def is_accessible_any(cls, *resource_names):
for res in resource_names:
if cls.is_accessible(res):
return True
@classmethod
def is_accessible(cls, resource_name):
if current_user.is_anonymous:
return False
user = User.query.get(current_user.id)
if not user:
return False
# superuser has accesses to all resources
if super_user_role in user.roles:
return True
for role in user.roles:
if role.name == resource_name:
return True
for resource in role.resources:
if resource.name == resource_name:
return True
return False
class User(db.Model, SerializerMixin):
__tablename__ = 'users'
serialize_only = ('id', 'username', 'email', 'created_on', 'last_login',
'authenticated', 'avatar_url')
serialize_rules = ('-password', '-songs')
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.Binary, nullable=False)
email = db.Column(db.String(50), unique=True, nullable=False)
created_on = db.Column(db.DateTime, nullable=False)
last_login = db.Column(db.DateTime, nullable=False)
authenticated = db.Column(db.Boolean, default=False, nullable=False)
avatar_url = db.Column(
db.String(100),
default=
'https://jwalls-fun-bucket.s3.amazonaws.com/profile-pics/default-profile-pic.jpg',
nullable=False)
songs = db.relationship('Song',
secondary=UserSongs,
backref='users',
cascade='all,delete')
def __init__(self, username, password, email) -> None:
self.username = username
self.password = password
self.email = email
self.created_on = dt.datetime.utcnow()
self.last_login = dt.datetime.utcnow()
def __repr__(self) -> str:
return 'hello'
class StoreModel(db.Model):
__tablename__ = 'stores'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
items = db.relationship('ItemModel', lazy='dynamic')
def __init__(self, name):
self.name = name
def json(self):
return {
'id': self.id,
'name': self.name,
'items': [item.json() for item in self.items.all()]
}
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(
name=name).first() #SELECT * FROM items WHERE name=name LIMIT 1
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
@classmethod
def find_all(cls):
return cls.query.all()
class ItemModel(db.Model):
__tablename__ = 'items'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
price = db.Column(db.Float(precision=2))
store_id = db.Column(db.Integer, db.ForeignKey('stores.id'))
stores = db.relationship('StoreModel')
def __init__(self, name, price, store_id):
self.name = name
self.price = price
self.store_id = store_id
def json(self):
return {
'name': self.name,
'price': self.price,
'store_id': self.store_id
}
@classmethod
def get_item_by_name(cls, name):
return cls.query.filter_by(name=name).first(
) # SELECT * FROM __tablename__ WHERE name = name LIMIT 1
def save_to_db(self):
db.session.add(self)
db.session.commit()
def del_from_db(self):
db.session.delete(self)
db.session.commit()
class UserAccount(BaseModel):
"""
User account model.
Args:
db : Model
"""
__tablename__ = 'user_account'
username = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(256), nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
email_confirmed = db.Column(db.Boolean, server_default='f')
normalized_email = db.Column(db.String(128), unique=True)
phone_number = db.Column(db.String(24), unique=True, nullable=True)
phone_number_confirmed = db.Column(
db.Boolean, nullable=True, server_default='f')
organization_id = db.Column(UUID, db.ForeignKey('organization.id'))
organization = relationship('Organization')
employee = db.relationship(
'Employee',
uselist=False,
backref='user_account'
)
def __repr__(self):
return '<User %r>' % self.username
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
admin = db.Column(db.Boolean, default=False)
username = db.Column(db.String(50), unique=True)
first_name = db.Column(db.String(50))
last_name = db.Column(db.String(50))
password = db.Column(db.String(80))
goal_daily_calories = db.Column(db.Float(), default=0)
goal_daily_protein = db.Column(db.Float(), default=0)
goal_daily_carbohydrates = db.Column(db.Float(), default=0)
goal_daily_fat = db.Column(db.Float(), default=0)
goal_daily_activity = db.Column(db.Float(), default=0)
application = db.relationship('Application',
backref='user',
lazy=True,
uselist=False)
def data(self):
return {
'username': self.username,
'firstName': self.first_name,
'lastName': self.last_name,
'goalDailyActivity': self.goal_daily_activity,
'goalDailyCalories': self.goal_daily_calories,
'goalDailyProtein': self.goal_daily_protein,
'goalDailyCarbohydrates': self.goal_daily_carbohydrates,
'goalDailyFat': self.goal_daily_fat,
'admin': self.admin
}
class RuleFilter(db.Model):
__tablename__ = "RuleFilter"
id = db.Column(db.Integer, primary_key=True)
idKey = db.Column(db.Integer, db.ForeignKey('RuleFilterKey.id'))
key = db.relationship("RuleFilterKey",
foreign_keys=[idKey],
cascade="merge")
value = db.Column(db.String(20), nullable=False)
idRule = db.Column(db.Integer, db.ForeignKey('Rule.id'))
rule = db.relationship("Rule",
foreign_keys=[idRule],
cascade="merge, delete")
def __init__(self, idKey=None, value=None):
self.idKey = idKey
self.value = value
class Product(db.Model):
__tablename__ = "product"
id = db.Column(db.String(36),
default=lambda: str(uuid4()),
primary_key=True)
name = db.Column(db.String(80), nullable=False)
description = db.Column(db.String(240), nullable=False)
price = db.Column(db.Float(10), nullable=False)
categories = db.relationship("Category", back_populates="product")
@validates('name')
def name_validate(self, key, name: str):
if not name:
raise ConflictException(msg='Product name is empty')
return name
@validates('description')
def description_validate(self, key, description: str):
if not description:
raise ConflictException(msg='Product description is empty')
return description
@validates('price')
def price_validate(self, key, price: str):
if not price:
raise ConflictException(msg='Product price is empty')
if re.findall('[a-zA-Z_+-,@#$%¨&*^~`´]', price):
raise ConflictException(
msg='Use only numbers and point in product price')
return price
class Candidate(db.Model):
mec_id = db.Column("MECID",
db.String,
primary_key=True,
unique=True,
nullable=False)
name = db.Column("Candidate Name", db.String)
committee_name = db.Column("Committee Name", db.String)
office_sought = db.Column("Office Sought", db.String)
# status = db.Column(db.String)
contributions = db.relationship(
"Contribution",
back_populates="candidate",
cascade="all, delete",
passive_deletes=True,
)
@classmethod
def df(self):
df = pd.read_sql("candidate", db.engine)
return df
# return pd.DataFrame()
@hybrid_property
def stats(self):
return {
"$ Raised":
sum(contribution.amount for contribution in self.contributions)
}
class CourseUser(ModelCommon, ModelSuper):
__tablename__ = 'course_users'
user_id = db.Column(db.String(36), db.ForeignKey(User.id))
course_id = db.Column(db.String(36), db.ForeignKey(Course.id))
user = db.relationship(User,
foreign_keys=user_id,
post_update=True,
uselist=False)
course = db.relationship(Course,
foreign_keys=course_id,
post_update=True,
uselist=False)
def __init__(self, dict):
ModelSuper.__init__(self, dict)
class Contribution(db.Model):
id = db.Column("CD1_A ID", db.Integer, primary_key=True)
date = db.Column("Date", db.Date, nullable=False)
mec_id = db.Column(" MECID", db.String, db.ForeignKey("candidate.MECID"))
# mec_id = db.Column(db.String)
candidate = db.relationship("Candidate", back_populates="contributions")
# contributor_id = db.Column(
# db.Integer,
# db.ForeignKey("contributor.id", ondelete="CASCADE"),
# )
# contributor = db.relationship(
# "Contributor", backref=db.backref("contributions", lazy=True)
# )
# lat = db.Column("Latitude", db.Float)
# lon = db.Column("Longitude", db.Float)
employer = db.Column("Employer", db.String)
occupation = db.Column("Occupation", db.String)
amount = db.Column("Amount", db.Float)
contribution_type = db.Column("Contribution Type", db.String)
# report = db.Column(db.String)
@classmethod
def df(self):
df = pd.read_sql("contribution", db.engine)
return df
@hybrid_property
def sum(self):
self.df["Amount"].sum()
class ItemModel(db.Model):
__tablename__ = 'items'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
price = db.Column(db.Float(precision=2))
store_id = db.Column(db.Integer, db.ForeignKey('stores.id'))
store = db.relationship('StoreModel')
#this init method creates an item model, so the item it is dealing with is the item itself
def __init__(self, name, price, store_id):
self.name = name
self.price = price
self.store_id = store_id
def json(self):
return {'name': self.name, 'price': self.price}
@classmethod
def find_item_by_name(cls, name):
#query object inherited from SQLAlchemy object in ItemModel
return cls.query.filter_by(
name=name).first() #SELECT * FROM items WHERE name = name LIMIT 1
#sqlAlchemy will do an update instead of an insert,
# because if something was called using an id, it just rewrites it?
#this method is good for updating and inserting data
def save_to_db(self):
db.session.add(
self
) #session is a collection of objects that we will write into the database
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class ItemModel(db.Model):
__tablename__ = "items"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
price = db.Column(db.Float(precision=2))
store_id = db.Column(db.Integer, db.ForeignKey("stores.id"))
store = db.relationship("StoreModel")
def __init__(self, name: str, price: str, store_id: int):
self.name = name
self.price = price
self.store_id = store_id
def json(self):
return {"name": self.name, "price": self.price}
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).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 StartupDataModel(db.Model):
__tablename__ = "startup_data"
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime, default=datetime.datetime.now())
angellist_url = db.Column(db.String)
crunchbase_url = db.Column(db.String)
# their web presence
startup_url = db.Column(db.String)
# leanworkbench username
username = db.Column(db.String)
vc_matcher_page = db.Column(db.Integer, default=0)
vc_matcher_done = db.Column(db.Boolean, default=False)
description = db.Column(db.Text, default=None)
vcs = db.relationship('VCModel', backref="startup_data", lazy="dynamic")
def as_dict(self):
return {
'angellist_url': self.angellist_url,
'crunchbase_url': self.crunchbase_url,
'description': self.description,
'vcs': [vc.as_dict() for vc in self.vcs]
}
def __str__(self):
return str(self.as_dict())
class ThreadModel(db.Model):
__tablename__ = 'threads'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.String(255), nullable=False)
genre_id = db.Column(db.String(10),
db.ForeignKey('genres.id'),
nullable=False)
book_id = db.Column(db.String(255),
db.ForeignKey('books.id'),
nullable=True)
# book_id = db.Column(db.String(255), nullable=True, ForeignKey('books.id'))
createTime = db.Column(db.DateTime, nullable=False, default=datetime.now)
updateTime = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
message = db.relationship("MessageModel")
def __init__(self, name, genre_id, book_id):
# self.id = id
self.name = name
self.genre_id = genre_id
self.book_id = book_id
def __repr__(self):
return '<ThreadModel {}:{}:{}:{}>'.format(self.id, self.name,
self.genre_id, self.book_id)
class Activity(db.Model):
__tablename__ = "activities"
activity_id = db.Column(db.Integer, primary_key=True)
team_id = db.Column(db.Integer, db.ForeignKey("teams.team_id"))
activity_name = db.Column(db.String, unique=True)
jira_project_id = db.Column(db.Integer, db.ForeignKey("jira_projects.id"))
sprints = db.relationship("Sprint", back_populates="activity")
# Set up relationship between Sprints belonging to teams
team = db.relationship("Team", back_populates="activities")
def __repr__(self):
return "<Activity: activity_id={}, activity_name={} jira_project_id={}>".format(
self.activity_id, self.activity_name, self.jira_project_id)
class UserExternalService(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
user = db.relationship(User, backref="external_services")
service = db.Column(db.String,
nullable=False) # UserExternalServiceEnum. _ .value
service_user_id = db.Column(db.String, nullable=False)
auth_info = db.Column(db.JSON) # e.g. access token
user_info = db.Column(db.JSON)
last_used_at = db.Column(db.DateTime(),
default=datetime.utcnow,
nullable=False)
__table_args__ = (
UniqueConstraint("user_id",
"service",
name="user_external_service_user_id_service_uniq"),
UniqueConstraint(
"service",
"service_user_id",
name="user_external_service_service_service_user_id_uniq",
),
)
class Todos(db.Model):
todo_id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.user_id'),
nullable=False)
todo_title = db.Column(db.String(255), nullable=False)
todo_body = db.Column(db.String(255), nullable=False)
completed = db.Column(db.Boolean, nullable=False, default=False)
created_at = db.Column(db.String(255), nullable=False, default=None)
completed_at = db.Column(db.String(255), nullable=True, default=None)
todosCategories = db.relationship('TodosCategories',
backref='todos',
lazy=True)
def __repr__(self):
reprDict = {
"user_id": self.user_id,
"todo_id": self.todo_id,
"todo_title": self.todo_title,
"todo_body": self.todo_body,
"completed": self.completed,
"created_at": self.created_at,
"completed_at": self.completed_at
}
return str(reprDict)
class Order(db.Model):
__tablename__ = 'orders'
id = db.Column('orderid',
db.Integer,
db.Sequence('orders_orderid_seq'),
primary_key=True,
server_default=db.FetchedValue())
orderdate = db.Column(db.Date, nullable=False)
customerid = db.Column(db.ForeignKey('customers.customerid',
ondelete='SET NULL'),
index=True)
netamount = db.Column(db.Numeric(12, 2), nullable=False)
tax = db.Column(db.Numeric(12, 2), nullable=False)
totalamount = db.Column(db.Numeric(12, 2), nullable=False)
customer = db.relationship('Customer',
primaryjoin='Order.customerid == Customer.id',
backref='orders')
def _asdict(self):
return {
"id": self.id,
"orderdate": self.orderdate,
"customerid": self.customerid,
"netamount": self.netamount,
"tax": self.tax,
"totalamount": self.totalamount,
"positions": self.positions
}
class StoreModel(db.Model):
__tablename__ = "stores"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
# it is a list of items that belong this store
items = db.relationship("ItemModel", lazy='dynamic')
def __init__(self, name):
self.name = name
def json(self):
return {
"name": self.name,
"items": [item.json() for item in self.items]
}
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).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 Orderline(db.Model):
__tablename__ = 'orderlines'
orderlineid = db.Column('orderlineid', db.Integer, primary_key=True)
orderid = db.Column('orderid',
db.ForeignKey('orders.orderid', ondelete='CASCADE'),
primary_key=True)
prod_id = db.Column('prod_id',
db.ForeignKey('products.prod_id'),
nullable=False)
quantity = db.Column('quantity', db.SmallInteger, nullable=False)
orderdate = db.Column('orderdate', db.Date, nullable=False)
order = db.relationship('Order',
primaryjoin="Orderline.orderid == Order.id",
backref="positions")
db.Index('ix_orderlines_orderid', 'orderid', 'orderlineid')
def _asdict(self):
return {
"orderlineid": self.orderlineid,
"orderid": self.orderid,
"product": self.product,
"quantity": self.quantity,
"orderdate": self.orderdate
}
class Match(db.Model):
__tablename__ = 'match'
idMatch = db.Column(db.Integer, primary_key=True)
session = db.Column(
db.JSON) # Domande, risposte corrette, [punteggio], stato match
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship("User", back_populates="games")
class Kinase(BioModel):
"""Kinase represents an entity interacting with some site.
The protein linked to a kinase is chosen as the `preferred_isoform` of a
gene having the same name as given kinase (since we do not have specific
refseq identifiers for a single kinase).
Not every kinase has an associated protein.
"""
name = db.Column(db.String(80), unique=True, index=True)
protein_id = db.Column(db.Integer, db.ForeignKey('protein.id'))
group_id = db.Column(db.Integer, db.ForeignKey('kinasegroup.id'))
site_type_table = make_association_table('kinase.id', SiteType.id)
is_involved_in = db.relationship(SiteType,
secondary=site_type_table,
collection_class=set,
backref='kinases')
def __repr__(self):
return f'<Kinase {self.name} belonging to {self.group} group>'
@property
def mutations(self):
if not self.protein:
return tuple()
return self.protein.mutations.all()
def to_json(self):
return {
'name': self.name,
'protein': {
'refseq': self.protein.refseq
} if self.protein else None
}
class Product(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(75), unique=True)
recipe = db.relationship('Recipe', backref='product', lazy=True)
def __repr__(self):
return self.name
location = geolocator.reverse(latlonstr,exactly_one=True)
print location
formatted = location.address.split(',')
self.address="%s %s" %(formatted[1].strip(),formatted[2].strip())
self.city=formatted[-4].strip()
self.state='CA'
self.zipcode=formatted[-2].strip()
self.stamp = set_stamp()
db.session.commit()
return location.address
except Exception, e:
print "REVERSE GEOCODER FINAL FAIL: %s." %(e)
return "1 Gateway Plaza, Los Angeles, CA"
# FKs
features = db.relationship('Feature', secondary=placefeatures,
backref=db.backref('placefeatures', lazy='dynamic'))
categories = db.relationship('Category', secondary=placecategories,
backref=db.backref('placecategories', lazy='dynamic'))
resource_fields = {
# for swagger
'name': fields.String(),
'description': fields.String(),
# 'category': fields.Integer(),
'pub_date': fields.DateTime( default=datetime.now() ),
'address': fields.String(),
'state': fields.String(),
'city': fields.String(),
'lat': fields.Float(default=0.0),
'lon': fields.Float(default=0.0),
'zipcode': fields.String(default='90012'),
