class Department(db.Model):
__tablename__ = 'Departments'
id = db.Column('id', db.Integer, primary_key=True, autoincrement=True)
name = db.Column('name', db.String)
description = db.Column('description', db.String)
def __init__(self,id,name,description):
self.id = id
self.name = name
self.description = description
def set_id(self, value):
self.id = value
def set_name(self, value):
self.name = value
def set_description(self,value):
self.description = value
def get_id(self):
return self.id
def get_name(self):
return self.name
def get_description(self):
return self.description
class ServiceRegistry(db.Model):
__tablename__ = "service_registry"
id = db.Column(db.Integer, primary_key=True)
service = db.Column(db.String(255), unique=True, nullable=False)
created_on = db.Column(db.DateTime, server_default=db.func.now())
updated_on = db.Column(db.DateTime,
server_default=db.func.now(),
onupdate=db.func.now())
class Tray(db.Model):
__tablename__ = 'trays'
id = db.Column(db.Integer, primary_key=True)
incubator_id = db.Column(db.Integer, db.ForeignKey('incubators.id'), nullable=False)
incubator = db.relationship('Incubator', backref=db.backref('trays'))
date_incubated = db.Column(db.DateTime, nullable=True)
eggs_contained = db.Column(db.Integer, nullable=False, default=0)
def __repr__(self):
return '<Role %r>' % self.id
class StudentInfo(db.Model):
__tablename__ = 'StudentInfos'
id = db.Column("id",
db.Integer,
db.ForeignKey('Users.id'),
primary_key=True)
name = db.Column("name", db.String)
pnc = db.Column("pnc", db.String) # CNP
student_function = db.Column("student_function",
db.String) # licenta/master
faculty = db.Column("faculty", db.String)
year = db.Column("year", db.Integer)
group = db.Column("group", db.String)
specialization = db.Column("specialization", db.String)
study_line = db.Column("study_line", db.String)
def __init__(self, student_id, name, pnc, student_function, faculty, year,
group, specialization, study_line):
self.id = student_id
self.name = name
self.pnc = pnc
self.student_function = student_function
self.faculty = faculty
self.year = year
self.group = group
self.specialization = specialization
self.study_line = study_line
def get_id(self):
return self.id
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True)
created_at = db.Column(db.DateTime, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
items = db.relationship('Item', backref='category', lazy='dynamic')
def __init__(self, username, email):
self.name = name
self.created_at = datetime.datetime.utcnow()
class Article(Base):
__tablename__='article'
by=db.Column(db.String(64))
url=db.Column(db.String(128))
title=db.Column(db.String(128))
score=db.Column(db.Integer)
def __init__(self,by,url,title,score):
self.url=url
self.title=title
self.score=score
self.by=by
class Post2(Base):
__tablename__ = 'post2'
title = db.Column(db.String(64))
body = db.Column(db.Text)
user_id = db.Column(db.Integer, db.ForeignKey('user2.id'))
def __init__(self, user_id, title, body):
self.user_id = user_id
self.title = title
self.body = body
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(120), unique=True)
created_at = db.Column(db.DateTime, nullable=False)
categories = db.relationship('Category', backref='user', lazy='dynamic')
items = db.relationship('Item', backref='user', lazy='dynamic')
def __init__(self, username, email):
self.username = username
self.email = email
self.created_at = datetime.datetime.utcnow()
class NotaMateria(db.Model):
__tablename__ = 'notamateria'
__table_args__ = {'extend_existing': True}
notamateria_id = db.Column(db.Integer, primary_key=True)
alumno_fk = db.Column(db.Integer)
nombremateria = db.Column(db.String(2))
notafinal = db.Column(db.Integer)
def __init__(self, alumno, nombremateria, notafinal):
self.alumno_fk = alumno,
self.nombremateria = nombremateria,
self.notafinal = notafinal
def save(self):
db.session.add(self)
db.session.commit()
def __repr__(self):
return '<id {}>'.format(self.notamateria_id)
@staticmethod
def buscarNotasMaterias():
#NotaMateria.query(func.count(User.id))
return NotaMateria.query.order_by(NotaMateria.alumno_fk).all()
@staticmethod
def buscarNotaMateriaByNotamateriaID(notamateria_id):
return NotaMateria.query.filter_by(
notamateria_id=notamateria_id).first()
@staticmethod
def getNotasMateriasByAlumnoID(id):
return NotaMateria.query.filter_by(alumno_fk=id).order_by(
NotaMateria.nombremateria).all()
'''query = NotaMateria.query.filter(User.name.like('%ed')).order_by(User.id)'''
'''return NotaMateria.query.filter_by(alumno_fk=id).first_or_404(description='No existe datos con el ID ={}'.format(id))'''
#session.query(User).filter_by(name='jack').count() hacer esto para verificar si fue eliminado
def delete(self):
db.session.delete(self)
db.session.commit()
def serializar(self):
return {
'notamateria_id': self.notamateria_id,
'alumno': self.alumno_fk,
'nombremateria': self.nombremateria,
'notafinal': self.notafinal
}
class Tenant(db.Model):
__tablename__ = 'user'
id = db.Column('id', db.String(60), primary_key=True, nullable=False)
fname = db.Column('fname', db.String(60), nullable=False)
mname = db.Column('mname', db.String(60), nullable=False)
lname = db.Column('lname', db.String(60), nullable=False)
sex = db.Column(db.String(6), nullable=False)
addressHome = db.Column('addressHome', db.String(60), nullable=False)
course = db.Column('course', db.String(60), nullable=False)
birth_date = db.Column(db.DATE, nullable=False)
def __init__(self,
id='',
fname='',
mname='',
lname='',
sex='',
addressHome='',
course='',
birth_date=""):
self.id = id
self.fname = fname
self.mname = mname
self.lname = lname
self.sex = sex
self.addressHome = addressHome
self.course = course
self.birth_date = birth_date
class StudentActivity(db.Model):
__tablename__ = 'StudentActivities'
id = db.Column("id", db.Integer, primary_key=True, autoincrement=True)
student_id = db.Column("student_id", db.Integer)
period = db.Column("period", db.String)
no_hours = db.Column("no_hours", db.Integer)
description = db.Column("description", db.Integer)
def __init__(self, id, student_id, period, no_hours, description):
self.id = id
self.student_id = student_id
self.period = period
self.no_hours = no_hours
self.description = description
class User2(db.Model):
__tablename__ = 'users2'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(), unique=True, nullable=False)
password = db.Column(db.String(), nullable=False)
email = db.Column(db.String(), unique=True)
def __init__(self, username, password, email):
self.username = username
self.password = password
self.email = email
def __repr__(self):
return "<E-mail %s>" % self.email
class Incubator(db.Model):
__tablename__ = 'incubators'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), unique=False, index=True, default='Incubator')
rows = db.Column(db.Integer, nullable=False)
columns = db.Column(db.Integer, nullable=False)
date_created = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
balot = db.Column(db.Integer, default=0)
freska = db.Column(db.Integer, default=0)
matra = db.Column(db.Integer, default=0)
echo = db.Column(db.Integer, default=0)
penoy = db.Column(db.Integer, default=0)
def __repr__(self):
return '<Role %r>' % self.name
class DeclaratieTraseu(db.Model):
__tablename__ = 'DeclaratieTraseu'
student_id = db.Column("student_id",
db.Integer,
db.ForeignKey('Users.id'),
primary_key=True)
submitted = db.Column("submitted", db.DateTime)
content = db.Column("content", db.PickleType)
checked = db.Column("checked", db.Boolean)
def __init__(self, student_id, submitted, content, checked):
self.student_id = student_id
self.submitted = submitted
self.content = content
self.checked = checked
class ComplianceRuleResults(db.Model):
__tablename__ = 'compliance_rule_results'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
ruleId = db.Column('rule_id',
db.Integer,
db.ForeignKey('rules.id'),
nullable=False)
provider = db.Column(db.String(100))
region = db.Column(db.String(100))
result = db.Column(db.String(100))
message = db.Column(db.Text)
timestamp = db.Column(db.Date)
rule = relationship("Rules", backref="rules")
def __init__(self, ruleId, provider, region, result, message, timestamp):
self.ruleId = ruleId
self.provider = provider
self.region = region
self.result = result
self.message = message
self.timestamp = timestamp
def __repr__(self):
return '<Result {} {} {}>'.format(self.ruleId, self.result,
self.message)
def toString(self):
return ({
'name': self.ruleId,
'region': self.region,
'message': self.message,
'provider': self.provider,
'rule': self.rule.toString(),
'result': self.result
})
class Rules(db.Model):
__tablename__ = 'rules'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100))
description = db.Column(db.String(100))
severity = db.Column(db.String(100))
rgroup = db.Column(db.String(100))
entity_type = db.Column(db.String(100))
provider = db.Column(db.String(100))
def __init__(self, name, description, severity, rgroup, entity, provider):
self.name = name
self.description = description
self.severity = severity
self.rgroup = rgroup
self.entity = entity
self.provider = provider
def toString(self):
groups = self.rgroup.split(",")
return ({
'name': self.description,
'description': self.description,
'severity': self.severity,
'groups': groups,
'provider': self.provider
})
def __repr__(self):
return '<Rule {} {}>'.format(seld.id, self.name)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
@login.user_loader
def load_user(id):
return User.query.get(int(id))
class StudentInternship(db.Model):
__tablename__ = 'StudentInternships'
internship_id = db.Column("internship_id", db.Integer,
db.ForeignKey('Internships.id'))
student_id = db.Column("student_id",
db.Integer,
db.ForeignKey('Users.id'),
primary_key=True)
tutor_id = db.Column("tutor_id", db.Integer, db.ForeignKey('Users.id'))
supervisor_id = db.Column("supervisor_id", db.Integer,
db.ForeignKey('Users.id'))
def __init__(self, internship_id, student_id, tutor_id, supervisor_id):
self.id = id
self.internship_id = internship_id
self.student_id = student_id
self.tutor_id = tutor_id
self.supervisor_id = supervisor_id
class Technology(db.Model):
__tablename__ = "Technologies"
id = db.Column('id', db.Integer, primary_key=True, autoincrement=True)
name = db.Column('name', db.String)
def __init__(self, id, name):
self.id = id
self.name = name
def set_id(self, value):
self.id = value
def set_name(self, value):
self.name = value
def get_id(self):
return self.id
def get_name(self):
return self.name
class User2(Base):
__tablename__= 'users2'
username= db.Column(db.String(), unique=True, nullable=False)
password= db.Column(db.String(), nullable=False)
email= db.Column(db.String(), unique=True)
def __init__(self, username, password, email):
self.username=username
self.password=bcrypt.generate_password_hash(password=password)
self.email=email
def check_password_hash(self,password):
if bcrypt.check_password_hash(pw_hash=self.password,password=password):
return True
else:
return False
def __repr__(self):
return "<E-mail %s>" % self.email
class Log(db.Model):
__tablename__ = 'logs'
id = db.Column(db.Integer, primary_key=True)
announcement_id = db.Column(db.Integer,
db.ForeignKey('announcements.id'),
nullable=False,
index=True)
is_seen = db.Column(db.Boolean, default=False)
is_submit = db.Column(db.Boolean, default=False)
created_at = db.Column(db.DateTime,
default=datetime.utcnow,
nullable=False)
status = db.Column(db.Boolean, default=False) # Checking status
def __repr__(self):
return '<Log {} {} {}>'.format(self.created_at, self.announcement_id,
self.is_seen)
def log_to_dict(self):
data = {
'id': self.id,
'created_at': self.created_at,
'announcement': 'announcement',
'status': self.status,
'is_seen': self.is_seen,
'is_submit': self.is_submit,
}
return data
class AcordPractica(db.Model):
__tablename__ = 'AcordPractica'
_id = db.Column("id", db.Integer, primary_key=True, autoincrement=True)
content = db.Column("content", db.String)
completedByFirmaReprezentant = db.Column("completedByFirmaReprezentant",
db.BOOLEAN)
completedByDepJuridicUBB = db.Column("completedByDepJuridicUBB",
db.BOOLEAN)
idFirmaReprezentant = db.Column("idFirmaReprezentant", db.Integer)
def __init__(self, content, idReprez):
self.content = content
self.completedByFirmaReprezentant = False
self.completedByDepJuridicUBB = False
self.idFirmaReprezentant = idReprez
def set_id(self, value):
self._id = value
def set_content(self, value):
self.content = value
def set_completedByFirmaReprezentant(self, value):
self.completedByFirmaReprezentant = value
def set_completedByDepJuridicUBB(self, value):
self.completedByDepJuridicUBB = value
def get_id(self):
return self._id
def get_content(self):
return self.content
def get_completedByFirmaReprezentant(self):
return self.completedByFirmaReprezentant
def get_completedByDepJuridicUBB(self):
return self.completedByDepJuridicUBB
class DailyHarvest(db.Model):
__tablename__ = 'harvests'
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime, nullable=False)
balot = db.Column(db.Integer, default=0)
freska = db.Column(db.Integer, default=0)
matra = db.Column(db.Integer, default=0)
echo = db.Column(db.Integer, default=0)
penoy = db.Column(db.Integer, default=0)
def __repr__(self):
return '<Role %r>' % self.name
class User2(Base):
__tablename__ = 'user2'
username = db.Column(db.String(), unique=True, nullable=False)
password = db.Column(db.String(), nullable=False)
email = db.Column(db.String(), unique=True)
posts = db.relationship('Post2', backref='author', lazy='dynamic')
is_admin = db.Column(db.Boolean, default=False)
is_active = db.Column(db.Boolean, default=False)
def __init__(self, username, password, email):
self.username = username
self.password = bcrypt.generate_password_hash(password=password)
self.email = email
def check_password_hash(self, password):
if bcrypt.check_password_hash(pw_hash=self.password,
password=password):
return True
else:
return False
def __repr__(self):
return "<E-mail %s>" % self.email
class ReportSession(db.Model):
__tablename__ = 'ReportSessions'
id = db.Column('id', db.Integer, primary_key=True, autoincrement=True)
project_id = db.Column(db.Integer, db.ForeignKey('Projects.id'))
user_id = db.Column(
db.Integer, db.ForeignKey('Users.id')) # ID-ul celui care da feedback
start_date = db.Column('start_date', db.DateTime)
end_date = db.Column('end_date', db.DateTime)
was_completed = db.Column(
'was_completed',
db.Boolean) # Userul a trimis sau nu feedback pentru sesiunea asta
def __init__(self, id, project_id, user_id, start_date, end_date,
was_completed):
self.id = id
self.project_id = project_id
self.user_id = user_id
self.start_date = start_date
self.end_date = end_date
self.was_completed = was_completed
def get_id(self):
return self.id
def get_project_id(self):
return self.project_id
def get_user_id(self):
return self.user_id
def get_start_date(self):
return self.start_date
def get_end_date(self):
return self.end_date
def get_was_completed(self):
return self.was_completed
def set_user_id(self, value):
self.user_id = value
def set_project_id(self, value):
self.project_id = value
def set_start_date(self, value):
self.start_date = value
def set_end_date(self, value):
self.end_date = value
def set_was_completed(self, value):
self.was_completed = value
def set_id(self, value):
self.id = value
class User_Project(db.Model):
__tablename__ = 'User_Project'
user_id = db.Column(db.Integer,
db.ForeignKey('Users.id'),
primary_key=True)
project_id = db.Column(db.Integer,
db.ForeignKey('Projects.id'),
primary_key=True)
def __init__(self, user_id, project_id):
self.user_id = user_id
self.project_id = project_id
def get_user_id(self):
return self.user_id
def get_project_id(self):
return self.project_id
def set_user_id(self, value):
self.user_id = value
def set_project_id(self, value):
self.project_id = value
class Report(db.Model):
__tablename__ = 'Reports'
id = db.Column('id', db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey(
'Users.id')) # ID-ul userului caruia i s-a facut report-ul
skill_id = db.Column(
db.Integer,
db.ForeignKey('Skills.id')) # Skill-ul pentru care s-a facut report
project_id = db.Column(db.Integer, db.ForeignKey(
'Projects.id')) # Proiectul in cadrul caruia s-a primit feedback
mark = db.Column('mark', db.Integer)
date = db.Column('date', db.DateTime)
def __init__(self, id, user_id, skill_id, project_id, mark, date):
self.id = id
self.user_id = user_id
self.skill_id = skill_id
self.project_id = project_id
self.mark = mark
self.date = date
def set_user_id(self, value):
self.user_id = value
def set_skill_id(self, value):
self.skill_id = value
def set_project_id(self, value):
self.project_id = value
def set_mark(self, value):
self.mark = value
def set_date(self, value):
self.date = value
def set_id(self, value):
self.id = value
def get_id(self):
return self.id
def get_user_id(self):
return self.user_id
def get_skill_id(self):
return self.skill_id
def get_project_id(self):
return self.project_id
def get_mark(self):
return self.mark
def get_date(self):
return self.date
class Project_Technology(db.Model):
__tablename__ = 'Project_Technology'
project_id = db.Column(db.Integer,
db.ForeignKey('Projects.id'),
primary_key=True)
technology_id = db.Column(db.Integer,
db.ForeignKey('Technologies.id'),
primary_key=True)
def __init__(self, project_id, technology_id):
self.project_id = project_id
self.technology_id = technology_id
def get_technology_id(self):
return self.technology_id
def get_project_id(self):
return self.project_id
def set_technology_id(self, value):
self.technology_id = value
def set_project_id(self, value):
self.project_id = value
class Item(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.Text, unique=True)
created_at = db.Column(db.DateTime, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
def __init__(self, username, email):
self.name = name
self.description = description
self.created_at = datetime.datetime.utcnow()
class ServiceInstance(db.Model):
__tablename__ = "service_instance"
service_id = db.Column(db.Integer,
db.ForeignKey('service_registry.id'),
primary_key=True)
host = db.Column(db.String(255), nullable=False, primary_key=True)
port = db.Column(db.String(255), nullable=False, primary_key=True)
health = db.Column(db.Integer)
created_on = db.Column(db.DateTime, server_default=db.func.now())
updated_on = db.Column(db.DateTime,
server_default=db.func.now(),
onupdate=db.func.now())
