class Total_leaves(db.Model):
id = db.Column(db.Integer, primary_key=True)
employee_id = db.Column(db.Integer, db.ForeignKey('employee.id'))
total_leaves = db.Column(db.Integer)
taken_leaves = db.Column(db.Integer)
def __init__(self, id, employee_id, total_leaves, taken_leaves):
self.id = id
self.total_leaves = total_leaves
self.taken_leaves = taken_leaves
class Telemetry(db.Model):
__tablename__ = 'telemetry'
datetime = db.Column(db.DateTime,
default=datetime.utcnow,
primary_key=True)
machineID = db.Column(db.Integer, db.ForeignKey('machines.machineID'))
volt = db.Column(db.Float, nullable=False)
rotate = db.Column(db.Float, nullable=False)
pressure = db.Column(db.Float, nullable=False)
vibration = db.Column(db.Float, nullable=False)
class Ideas(db.Model):
__tablename__ = "ideas"
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text)
author = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
users_who_liked = db.relationship('Users', secondary=likes)
@classmethod
def post_validation(cls, user_info):
is_valid = True
if len(user_info['idea']) < 1:
is_valid = False
flash("Please enter a post before submitting!", "danger")
elif len(user_info['idea']) < 10:
is_valid = False
flash("Please enter at least 10 characters.", "danger")
return is_valid
@classmethod
def add_post(cls, user_info):
flash("Idea posted!", "success")
new_post = cls(content=user_info['idea'], author=session['userid'])
db.session.add(new_post)
db.session.commit()
@classmethod
def like(cls, id):
idea_count = 0
all_users = Users.query.all()
current_idea = cls.query.get(int(id))
current_user = Users.query.get(session['userid'])
for user in all_users:
for liked_idea in user.liked_ideas:
if liked_idea == current_idea:
idea_count += 1
if current_user in current_idea.users_who_liked:
current_idea.users_who_liked.remove(current_user)
db.session.commit()
flash("Idea unliked.", "info")
else:
current_idea.users_who_liked.append(current_user)
db.session.commit()
flash("Idea liked!", "success")
@classmethod
def delete(cls, id):
all_users = Users.query.all()
current_idea = cls.query.get(int(id))
for user in all_users:
for idea in user.liked_ideas:
if idea == current_idea:
current_idea.users_who_liked.remove(user)
db.session.delete(current_idea)
db.session.commit()
flash("Idea deleted.", "info")
class Event(db.Model):
__tablename__ = 'Event'
event_id = db.Column(UUID(as_uuid=True),
default=uuid.uuid4,
primary_key=True)
creator_id = db.Column(UUID(as_uuid=True),
db.ForeignKey('User.user_id'),
nullable=False)
organization_id = db.Column(UUID(as_uuid=True),
db.ForeignKey('Organization.organization_id'),
nullable=False)
event_name = db.Column(db.String(250), nullable=False)
start_date = db.Column(db.DateTime,
default=datetime.utcnow,
nullable=False)
end_date = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
theme = db.Column(db.String(250), nullable=False)
perks = db.Column(db.String(250), nullable=False)
categories = db.Column(db.String(250), nullable=False)
info = db.Column(db.String(2500), nullable=False)
phase = db.Column(db.Enum(EventPhase), nullable=False)
contact_id = db.Column(UUID(as_uuid=True),
db.ForeignKey('Contact.contact_id'),
nullable=False)
image_url = db.Column(db.String(255))
creator = db.relationship('User', lazy=True)
organization = db.relationship('Organization', lazy=True)
contact = db.relationship('Contact', lazy=True)
'''def __init__(self, creator_id, organization_id, event_name, start_date, end_date, theme, perks, categories, info, phase, contact_id):
self.creator_id = creator_id
self.organization_id = organization_id
self.event_name = event_name
self.start_date = start_date
self.end_date = end_date
self.theme = theme
self.perks = perks
self.categories = categories
self.info = info
self.phase = phase
self.contact_id = contact_id'''
'''
class Animal(db.Model):
id = db.Column(db.Integer, primary_key=True)
nome_animal = db.Column(db.String(40), nullable=False)
familia = db.Column(db.String(40), nullable=False)
altura_media = db.Column(db.Float, nullable=False)
peso_medio = db.Column(db.Float, nullable=False)
habitat = db.Column(db.String(40), nullable=False)
conteudo = db.Column(db.Text, nullable=False)
imagem_postagem = db.Column(db.String(40),
nullable=False,
default='imagens/logo.png')
cuidadorid = db.Column(db.Integer,
db.ForeignKey(Cuidador.id),
nullable=False)
cuidadores = db.relationship("Cuidador")
zoologicoanimalid = db.Column(db.Integer,
db.ForeignKey(Zoologico.id),
nullable=False)
zoologicoanimal = db.relationship("Zoologico")
def __str__(self):
return self.id + str(
self.nome_animal
) + " ," + self.familia + " ," + self.altura_media + " ," + self.peso_medio + " ," + self.habitat + " ," + self.conteudo + " ," + self.imagem_postagem + " ," + str(
self.cuidadorid) + ", " + self.cuidadores + ", " + str(
self.zoologicoanimalid) + ", " + self.zoologicoanimal
def json(self):
return {
"id": self.id,
"nome_animal": self.nome_animal,
"familia": self.familia,
"altura_media": self.altura_media,
"peso_medio": self.peso_medio,
"habitat": self.habitat,
"conteudo": self.conteudo,
"imagem_postagem": self.imagem_postagem,
"cuidadorid": self.cuidadorid,
"cuidadores": self.cuidadores.json(),
"zoologicoanimalid": self.zoologicoanimalid,
"zoologicoanimal": self.zoologicoanimal.json()
}
class Daily_intake(db.Model): #Суточная доза
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
date = db.Column(db.DateTime, default=datetime.utcnow)
calorie = db.Column(db.Integer)
proteins = db.Column(db.Integer)
fats = db.Column(db.Integer)
carbohydrates = db.Column(db.Integer)
def __repr__(self):
return '<Daily_intake {}>'.format(self.username)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True) # primary keys are required by SQLAlchemy
organization = db.Column(db.Integer, db.ForeignKey('organization.id'))# add foreign key
email = db.Column(db.String(100), unique=True)
password = db.Column(db.String(100))
name = db.Column(db.String(1000))
tn_api_key = db.Column(db.String(50))
role = db.Column(db.String(50), default='user')
created_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now())
updated_at = db.Column(db.DateTime(timezone=True), server_default=db.func.now(), onupdate=db.func.now())
new_user = db.Column(db.Boolean, default=True)
class interfaces(db.Model):
id = db.Column(db.Integer, primary_key=True)
linecard_id = db.Column(db.Integer, db.ForeignKey('linecards.id'))
interface_type_id = db.Column(db.Integer,
db.ForeignKey('interface_types.id'))
int_profile_type_id = db.Column(db.Integer,
db.ForeignKey('int_profile_types.id'))
linecard_port_num = db.Column(db.Integer)
ip_address_v4 = db.Column(db.String(15))
ip_snm_v4 = db.Column(db.String(15))
comment = db.Column(db.String(255))
installed_in_linecards = db.relationship(
'linecards',
back_populates='interfaces_installed') # bidirectionally confirmed
int_profile = db.relationship(
'int_profile_types',
back_populates='interfaces_with_profile') # bidirectionally confirmed
interface_type = db.relationship(
'interface_types',
back_populates='interfaces_with_type') # bidirectionally confirmed
class Event(db.Model):
__Tablename__ = "events"
id = db.Column(db.Integer, primary_key=True)
event_title = db.Column(db.String(100))
date = db.Column(db.String(8))
time = db.Column(db.String(12))
location = db.Column(db.String(100))
information = db.Column(db.TEXT)
creator_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
author = db.relationship('User', foreign_keys=[creator_id], backref="user_messages", cascade="all")
events_that_have_attendees = db.relationship('User', lazy = 'dynamic', secondary = attendees_table)
class Event(db.Model):
__tablename__ = "events"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100))
description = db.Column(db.String(255))
date = db.Column(db.String(45))
time = db.Column(db.String(45))
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='cascade'))
user = db.relationship('User', foreign_keys=[user_id])
location_id = db.Column(
db.Integer, db.ForeignKey('event_locations.id', ondelete='cascade'))
location = db.relationship('Event_location', foreign_keys=[location_id])
all_comment = db.relationship('Event_comment',
back_populates="event",
cascade="all, delete, delete-orphan")
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
class Eatlist(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
recipe_id = db.Column(db.Integer, db.ForeignKey('recipe.id'))
date_last_added = db.Column(db.DateTime)
date_last_bought = db.Column(db.DateTime)
def __init__(self, user, recipe):
if isinstance(user, User):
self.user = user
else:
self.user_id = user
if isinstance(recipe, Recipe):
self.recipe = recipe
else:
self.recipe_id = recipe
def __repr__(self):
return '<Eatlist - ({},{})>'.format(str(self.user_id),
str(self.recipe_id))
class Regla(db.Model):
__tablename__ = "reglas"
id_regla = db.Column(db.Integer, primary_key=True)
city = db.Column(db.String(60), nullable=False)
country = db.Column(db.String(50), nullable=False)
sku = db.Column(db.String(50),
db.ForeignKey('descripciones.sku'),
nullable=False)
min_condition = db.Column(db.Integer, nullable=False)
max_condition = db.Column(db.Integer, nullable=False)
variation = db.Column(db.Float, nullable=False)
class IncomingLog(db.Model):
id = db.Column(db.Integer, primary_key=True)
org_id = db.Column(db.Integer, db.ForeignKey('organization.id'))
service = db.Column(db.String(100))
call_start_time = db.Column(db.DateTime)
call_end_time = db.Column(db.DateTime)
call_duration = db.Column(db.Float)
complete = db.Column(db.Boolean)
incoming_number = db.Column(db.Integer)
extension = db.Column(db.Integer)
status = db.Column(db.String(100))
generalized_data_incoming = db.Column(
db.Integer, db.ForeignKey('generalized_data_incoming.id'))
org_ids = relationship('Organization', foreign_keys='IncomingLog.org_id')
generalized_data_incomings = relationship(
'GeneralizedDataIncoming',
foreign_keys='IncomingLog.generalized_data_incoming')
comments = relationship('Comment',
backref=backref("IncomingLog", lazy="joined"))
class Recipe(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100), nullable=False)
description = db.Column(db.Text, nullable=False)
ingredients = db.Column(db.Text(), nullable=False)
instructions = db.Column(db.Text, nullable=False)
under30 = db.Column(db.String(3), default="Yes", nullable=False)
author_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
author = db.relationship('User', foreign_keys=[
author_id], backref='recipes', lazy=True)
users_who_like_this_recipe = db.relationship('User', secondary=likes_table)
class subProject(db.Model):
__tablename__ = 'sub_project'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50))
parent_project_id = db.Column(db.Integer,
db.ForeignKey('parent_project.id'))
parent_project = db.relationship('parentProject',
backref=db.backref('sub_project',
lazy='dynamic'))
last_update = db.Column(db.DATETIME, default=datetime.datetime.now())
is_deleted = db.Column(db.BOOLEAN, default=False)
class Tweet(db.Model):
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.String(240))
author_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
author = db.relationship('User',
foreign_keys=[author_id],
backref="user_tweets")
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
class Answers(db.Model):
__tablename__ = "answertable"
answerid = db.Column(db.Integer, primary_key=True, autoincrement=True)
responseid = db.Column(db.Integer,
db.ForeignKey("responsetable.responseid"))
questionumber = db.Column(db.Integer)
response1 = db.Column(db.Integer, nullable=True)
response2 = db.Column(db.Integer, nullable=True)
response3 = db.Column(db.Integer, nullable=True)
response4 = db.Column(db.Integer, nullable=True)
response5 = db.Column(db.Integer, nullable=True)
class Todos(db.Model):
__tablename__ = 'todos'
task_id = db.Column(db.Integer, primary_key=True)
task = db.Column(db.String(200))
completed = db.Column(db.Boolean)
timestamp = db.Column(db.DateTime,
default=datetime.utcnow,
onupdate=datetime.utcnow)
person_hash = db.Column(db.Integer,
db.ForeignKey('guard.hash_id'),
nullable=False)
class Picture(db.Model):
__tablename__ = "pictures"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
name = db.Column(db.String(255))
description = db.Column(db.Text)
file_path = db.Column(db.String(255))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
in_albums = db.relationship('Album', secondary=album_has_pictures)
user = db.relationship('User',
foreign_keys=[user_id],
backref=db.backref("pictures",
cascade="all,delete-orphan"))
def delete_from_disk(self):
if os.path.exists('UserFiles/' + self.file_path):
os.remove('UserFiles/' + self.file_path)
if os.path.exists('UserFiles/thumbnails' + self.file_path):
os.remove('UserFiles/thumbnails/' + self.file_path)
print("delete success: ", self)
else:
print("delete fail: ", self)
@classmethod
def new(cls, user_id, file_path, name):
"""
Add a new file to the Picture table.
new(user_id,file_path,name)
"""
new_pic = Picture(user_id=user_id,
name=name,
description="",
file_path=file_path)
db.session.add(new_pic)
db.session.commit()
return new_pic
@classmethod
def delete(cls, picture_id):
pic = Picture.query.get(picture_id)
db.session.delete(pic)
db.session.commit()
@classmethod
def update_info(cls, picture_info):
pic = Picture.query.get(picture_info['picture_id'])
if "picture_description" in picture_info.keys():
pic.description = picture_info['picture_description']
if "picture_name" in picture_info.keys():
pic.name = picture_info['picture_name']
db.session.commit()
class Person(db.Model):
__tablename__ = 'person'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
lname = db.Column(db.String(32), index=True)
fname = db.Column(db.String(32))
cell = db.Column(db.String(13))
occupation = db.Column(db.String(32))
location = db.Column(db.String(32))
email = db.Column(db.String(32),nullable=True)
timestamp = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
class EventSizeRestriction(db.Model):
__tablename__ = "size_restrictions"
id = db.Column(db.Integer, primary_key=True)
event_id = db.Column(db.Integer, db.ForeignKey('events.id'), nullable=False)
size_id = db.Column(db.Integer, db.ForeignKey('dog_sizes.id'), nullable=False)
size = db.relationship('DogSize', backref=backref("event_restrictions", cascade="all, delete-orphan"))
@classmethod
def add_restriction(cls, data):
restriction = EventSizeRestriction(event_id=data['event_id'], size_id=data['restriction'])
db.session.add(restriction)
db.session.commit()
return restriction
@classmethod
def remove_restriction(cls, data):
restriction = EventSizeRestriction.query.filter_by(event_id=data['event'], size_id=data['size_id']).first()
db.session.delete(restriction)
db.session.commit()
return
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
org_id = db.Column(db.Integer, db.ForeignKey('organization.id'))
name = db.Column(db.String(100))
username = db.Column(db.String(100))
password = db.Column(db.String(100))
phone = db.Column(db.Integer)
email = db.Column(db.String(100))
created = db.Column(db.DateTime)
org_ids = relationship('Organization', foreign_keys='User.org_id')
class Notification(db.Model):
__tablename__ = 'notifications'
id = db.Column(db.Integer, primary_key=True)
listing_id = db.Column(db.Integer,
db.ForeignKey("listings.id",
ondelete="cascade",
onupdate='cascade'),
nullable=False)
receiver_id = db.Column(db.Integer,
db.ForeignKey("users.id",
ondelete="cascade",
onupdate='cascade'),
nullable=False)
sender_id = db.Column(db.Integer)
listing = db.relationship("Listing",
foreign_keys=[listing_id],
backref="notif_listings")
receiver = db.relationship("User",
foreign_keys=[receiver_id],
backref="notif_users")
class Estate(db.Model):
id = db.Column(db.Integer, primary_key=True)
id_owner = db.Column(db.Integer, db.ForeignKey("user.id"))
name = db.Column(db.Text)
description = db.Column(db.Text)
re_type = db.Column(db.Text)
city = db.Column(db.Text)
rooms = db.relationship('Room',
back_populates="estate_parent",
cascade="all, delete-orphan",
lazy='dynamic')
class L2AllocationPool(db.Model):
__tablename__ = "l2allocationpool"
l2allocationpool_id = db.Column(db.Integer, primary_key=True)
l2allocationpool_first_ip = db.Column(db.String(64))
l2allocationpool_last_ip = db.Column(db.String(64))
l2allocationpool_site = db.Column(db.String(64))
lmaster_id = db.Column(db.Integer, db.ForeignKey('lmaster.lmaster_id'))
def get_string_allocation_pool(self):
answer = self.l2allocationpool_first_ip + "-" + self.l2allocationpool_last_ip
return answer
class Message(db.Model):
__tablename__ = "messages"
id = db.Column(db.Integer, primary_key=True)
message = db.Column(db.String(255))
player_id = db.Column(db.Integer,
db.ForeignKey("players.player_id"),
nullable=True)
player = db.relationship("Player",
foreign_keys=[player_id],
back_populates="messages")
game_id = db.Column(
db.Integer, db.ForeignKey("games.id"),
nullable=True) # is null if not in a game while sending message
game = db.relationship("Game",
foreign_keys=[game_id],
backref="game_messages")
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
class GeneOntology(db.Model):
__tablename__ = "gene_ontology"
gene_ontology_ID = db.Column(db.Integer, primary_key=True)
gene_ID = db.Column(db.Integer,
db.ForeignKey('gene.gene_ID'),
nullable=False)
gene = relationship("Gene", foreign_keys=[gene_ID])
gene_ontology_symbol = db.Column(db.String(32))
description = db.Column(db.String(32))
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
commenter = db.Column(db.String(80))
body = db.Column(db.Text)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
post = db.relationship('Post', backref=db.backref('comments', lazy='dynamic'))
def __init__(self, commenter, body, post_id):
self.commenter = commenter
self.body = body
self.post_id = post_id
class FavoriteSpot(db.Model):
__tablename__ = 'FavoriteSpots'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('Users.id'), nullable=False)
spot_id = db.Column(db.Integer, db.ForeignKey('Spots.id'), nullable=False)
created_time = db.Column(db.TIMESTAMP(timezone=True),
nullable=False,
server_default=func.now())
def __init__(self, user_id, spot_id):
self.user_id = user_id
self.spot_id = spot_id
def to_dict(self):
return dict(
user_id=self.user_id,
spot_id=self.spot_id,
created_time=self.created_time,
)
class Requests(db.Model):
__tablename__ = "requests"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey("users.id", ondelete="cascade"),
nullable=False)
user = db.relationship("Users",
foreign_keys=[user_id],
backref="requests",
cascade="all")
item_id = db.Column(db.Integer,
db.ForeignKey("items.id", ondelete="cascade"),
nullable=False)
item = db.relationship("Items",
foreign_keys=[item_id],
backref="requests",
cascade="all")
message = db.Column(db.String(255))
@classmethod
def submit_request(cls, data):
valid = True
if int(data["item_id"]) < 1:
valid = False
flash("an item must be selected to make request!")
if len(data["message"]) > 255:
valid = False
flash("message length must be under 255 characters!")
return valid
@classmethod
def add_request(cls, data):
new_request = cls(user_id=data["user_id"],
item_id=data["item_id"],
message=data["message"])
db.session.add(new_request)
db.session.commit()
@classmethod
def delete_request(cls, data):
pass
