class Post(db.Model):
__tablename__ = 'post'
id = db.Column('id', db.Integer, primary_key=True)
verified = db.Column('verified', db.Integer, default=0, nullable=True)
title = db.Column('title', db.String(70), nullable=True)
category = db.Column('category', db.String(10), nullable=True)
description = db.Column('description', db.String(100), nullable=True)
files = db.Column('file', db.String)
date = db.Column('Date', db.String, nullable=True)
user_id = db.Column('user_id', db.Integer, db.ForeignKey('user.id'), nullable=True)
start_time = db.Column("Start Time", db.String, nullable=True)
end_time = db.Column('End time', db.String, nullable=True)
lesson = db.relationship('Lesson', backref=db.backref('lessons'))
def __repr__(self, id, verified, title, category, description, files, date, user_id, start_time,
end_time):
self.id = id
self.verified = verified
self.title = title
self.category = category
self.files = files
self.description = description
self.date = date
self.user_id = user_id
self.start_time = start_time
self.end_time = end_time
class PorukaModel(db.Model):
__tablename__ = 'poruke'
id = db.Column(db.Integer, primary_key=True)
datum = db.Column(db.DateTime)
email = db.Column(db.String)
sadrzaj = db.Column(db.String)
def __init__(self, email, sadrzaj):
self.datum = datetime.now()
self.email = email
self.sadrzaj = sadrzaj
def json(self):
return {
'id': self.id,
'datum': self.datum,
'email': self.email,
'sadrzaj': self.sadrzaj
}
@classmethod
def find_all(cls):
return cls.query.all()
@classmethod
def find_for_id(cls, porukaID):
return cls.query.filter_by(id=porukaID).first()
def add(self):
db.session.add(self)
db.session.commit()
class ThreadAssoc(db.Model):
__tablename__ = 'user_to_thread'
__table_args__ = (db.PrimaryKeyConstraint('user_id', 'thread_id'), )
user_id = db.Column(db.Integer, db.ForeignKey('users.id')) # nullable?
user = db.relationship('User', back_populates='active_threads')
# thread is unaware of assocs referencing it?
# on thread deletion can call subroutine to delete thread Assocs (linear time)
# should cascade thread deletions to assoc deletions
# Many (assocs) to One (Thread)
thread_id = db.Column(db.Integer, db.ForeignKey('pleep_threads.id'))
thread = db.relationship('Thread')
# metadata
# by existing this assoc may already suggest metadata
state = db.Column(db.Boolean, nullable=False, default=True)
notifications = db.Column(db.Integer, nullable=False, default=0)
def jsonify(self):
return {
'user_id': self.user_id,
'thread_id': self.thread_id,
'state': self.state
}
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default="default.jpg")
password = db.Column(db.String(60), nullable=False)
posts = db.relationship("Post", backref="author", lazy=True)
def get_reset_token(self, expires_sec=1800):
s = Serializer(current_app.config["SECRET_KEY"],
expires_in=expires_sec)
return s.dumps({"user_id": self.id}).decode("utf-8")
@staticmethod
def verify_reset_token(token):
s = Serializer(current_app.config["SECRET_KEY"])
try:
user_id = s.loads(token)["user_id"]
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class Lokacija(db.Model):
__tablename__ = 'Lokacija'
id = db.Column(db.Integer, primary_key=True)
lat = db.Column(db.Float())
lng = db.Column(db.Float())
vreme = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
korisnik_id = db.Column(db.Integer,
db.ForeignKey('Korisnik.id'),
nullable=False)
def __init__(self, lat, lng, korisnik_id):
self.lat = lat
self.lng = lng
self.korisnik_id = korisnik_id
def json(self):
return {
'id': self.id,
'lat': self.lat,
'lng': self.lng,
'vreme': self.vreme,
'korisnik': self.korisnik_id
}
def update(self, new_score):
self.score += new_score
db.session.commit()
def add(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Odgovor(db.Model):
__tablename__='Odgovor'
id=db.Column(db.Integer,primary_key=True,autoincrement=True)
text = db.Column(db.String(50))
tacan = db.Column(db.Boolean())
pitanje_id = db.Column(db.Integer, db.ForeignKey('Pitanje.id'),nullable=False)
def __init__(self,text,tacan,pitanje_id):
self.text=text
self.tacan=tacan
self.pitanje_id=pitanje_id
def json(self):
return {
'id' : self.id,
'text' : self.text,
'tacan':self.tacan,
'pitanje': self.pitanje_id
}
@classmethod
def vrati_sve_za_pitanje(cls,id):
return cls.query.filter_by(pitanje_id=id)
@classmethod
def vrati_odgovor(cls,id):
return cls.query.filter_by(id=id).first()
def add(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Kviz(db.Model):
__tablename__='Kviz'
id=db.Column(db.Integer,primary_key=True,autoincrement=True)
datum=db.Column(db.DateTime)
destinacija_id = db.Column(db.Integer, db.ForeignKey('Destinacija.id'),nullable=False)
def __init__(self,datum,destinacija):
# '09/19/18 13:55:26' format
datum = datetime.strptime(datum, '%m/%d/%y %H:%M:%S')
self.datum=datum
self.destinacija_id=destinacija
def json(self):
return {
'id' : self.id,
'datum' : self.datum.strftime('%m/%d/%y %H:%M:%S'),
'vreme':str(self.datum.hour)+':'+str(self.datum.minute),
'destinacija':self.destinacija_id
}
@classmethod
def vrati_kviz(cls,id):
return cls.query.filter_by(id=id).first()
@classmethod
def vrati_sve(cls):
return cls.query.filter(Kviz.datum>datetime.now()).all()
def add(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Pitanje(db.Model):
__tablename__='Pitanje'
id=db.Column(db.Integer,primary_key=True,autoincrement=True)
text=db.Column(db.String(50))
kviz_id = db.Column(db.Integer, db.ForeignKey('Kviz.id'),nullable=False)
def __init__(self,text,kviz_id):
self.text=text
self.kviz_id=kviz_id
def json(self):
return {
'id' : self.id,
'text' : self.text,
'kviz' : self.kviz_id
}
@classmethod
def vrati_sve_za_kviz(cls,id):
return cls.query.filter_by(kviz_id=id)
def add(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Comment(db.Model):
__tablename__ = 'comment'
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text)
timestamp = db.Column(db.DateTime, index=True, default=datetime.datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
upload_id = db.Column(db.Integer, db.ForeignKey('upload.id'))
class sedeModel(db.Model):
__tablename__ = 'ci_sedes'
#__table_args__ = {'schema':'UBBJ_01'}
id_sede = db.Column(db.Integer, primary_key=True)
id_localidad = db.Column(db.Integer, nullable=True)
colonia = db.Column(db.String(45), nullable=True)
calle = db.Column(db.String(255), nullable=True)
numero = db.Column(db.String(255), nullable=True)
codigo_postal = db.Column(db.Integer, nullable=True)
fecha_actualizacion = db.Column(db.DateTime(timezone=True),
onupdate=func.now())
fecha_creacion = db.Column(db.DateTime(timezone=True),
server_default=func.now())
b_estado = db.Column(db.Boolean, nullable=True)
id_status = db.Column(db.Integer, nullable=True)
def save_to_db(self):
db.session.add(self)
db.session.commit()
db.session.refresh(self)
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id_sede=id).first()
@classmethod
def supdate_sede(cls, id, id_localidad, colonia, calle, numero,
codigo_postal, b_estado):
db.session.query(cls).filter(cls.id_sede == id).\
update({cls.id_localidad:id_localidad,
cls.colonia:colonia,
cls.calle:calle,
cls.numero:numero,
cls.codigo_postal:codigo_postal,
cls.b_estado:b_estado,
cls.id_status:5}, synchronize_session=False)
db.session.commit()
@classmethod
def fupdate_sede(cls, id):
db.session.query(cls).filter(cls.id_sede == id).\
update({cls.id_status:4}, synchronize_session=False)
db.session.commit()
@classmethod
def tupdate_sede(cls, id):
db.session.query(cls).filter(cls.id_sede == id).\
update({cls.id_status:6}, synchronize_session=False)
db.session.commit()
@classmethod
def return_all(cls):
def to_json(x):
return {'id_sede': x.id_sede, 'b_estado': x.b_estado}
return {
'sedes': list(map(lambda x: to_json(x), sedeModel.query.all()))
}
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return '<Post {}>'.format(self.body)
class Lesson(db.Model):
id = db.Column(db.Integer,primary_key=True)
title = db.Column(db.String(100),nullable=False)
date_posted = db.Column(db.DateTime,nullable=False,default=datetime.utcnow)
content = db.Column(db.Text,nullable=False)
user_id = db.Column(db.Integer,db.ForeignKey('user.id'),nullable=False)
def __repr__(self):
return f"User('{self.title}','{self.date_posted}')"
class User(db.Model, UserMixin):
id = db.Column(db.Integer,primary_key=True)
username = db.Column(db.String(20),unique=True,nullable=False)
email = db.Column(db.String(120),unique=True,nullable=False)
image_file = db.Column(db.String(20),nullable=False,default='default.jpg')
password = db.Column(db.String(60),nullable=False)
lessons = db.relationship('Lesson',backref='author',lazy=True)
def __repr__(self):
return f"User('{self.username}','{self.email}','{self.image_file}')"
class Answer(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
date_posted = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Post('{self.content}', '{self.date_posted}', '{self.post}', '{self.author}')"
class User(db.Model):
socketID = db.Column(db.String(32), primary_key=True)
sessionID = db.Column(db.String(30))
def __init__(self, socketID, sessionID):
self.socketID = socketID
self.sessionID = sessionID
def __repr__(self):
return "Socket user %s accessing %s" % (self.socketID, self.sessionID)
class im_ResgistroSedeModel(db.Model):
__tablename__ = 'im_registro_sede'
#__table_args__ = {'schema':'UBBJ_01'}
id_imagen_registro_sede = db.Column(db.Integer, primary_key=True)
id_imagen = db.Column(db.Integer, nullable=False)
id_reg_sed_columna = db.Column(db.Integer, nullable=False)
def save_to_db(self):
db.session.add(self)
db.session.commit()
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
def __repr__(self):
return f"Post('{self.title}', '{self.created_at}')"
class DocRegSedesModel(db.Model):
__tablename__ = 'ci_doc_reg_sedes'
#__table_args__ = {'schema':'UBBJ_01'}
id_doc_reg_sede = db.Column(db.Integer, primary_key=True)
id_reg_sed_columna = db.Column(db.Integer, nullable=False)
id_documento = db.Column(db.Integer, nullable=False)
def save_to_db(self):
db.session.add(self)
db.session.commit()
class user_rolModel(db.Model):
__tablename__ = 'ci_roles_usuario'
#__table_args__ = {'schema':'UBBJ_01'}
id_rol_usuario = db.Column(db.Integer, primary_key=True)
id_rol = db.Column(db.Integer, nullable=False)
id_usuario = db.Column(db.Integer, nullable=False)
b_logico = db.Column(db.Integer, nullable=False)
def save_to_db(self):
db.session.add(self)
db.session.commit()
class schoolLocation(db.Model):
id = db.Column(db.Integer, primary_key=True)
ncesid = db.Column(db.String(10))
urbanOrRural = db.Column(db.String(10))
def __init__(self, ncesid, urbanOrRural):
self.ncesid = ncesid
self.urbanOrRural = urbanOrRural
def __repr__(self):
return '<schoolLocation {}>'.format(self.ncesid)
class Inventory(db.Model):
"""Inventories are the groups in which the items are located"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True)
items = db.relationship('Item')
def __init__(self, name):
self.name = name
def serialize(self):
return {'id': self.id, 'name': self.name}
class Lesson(db.Model):
__tablename__ = 'lesson'
id = db.Column('id', db.Integer, primary_key=True)
title = db.Column('title', db.String(100), nullable=True)
description = db.Column('description', db.String(100), nullable=True)
post_id = db.Column('post_id', db.Integer, db.ForeignKey('post.id'), nullable=False)
user_id = db.Column('user_id', db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self, id, title, description, post_id):
self.id = id
self.title = title
self.description = description
self.post_id = post_id
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
designation = db.Column(db.String(50), nullable=False)
dept = db.Column(db.String(150), nullable=False)
image_file = db.Column(db.String(20), nullable=False, default='default.jpg')
password = db.Column(db.String(60), nullable=False)
is_admin = db.Column(db.Boolean, default=False, nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
answers = db.relationship('Answer', backref='author', lazy=True)
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}', '{self.designation}', '{self.dept}', '{self.is_admin}')"
class Post(db.Model):
__tablename__ = 'posts'
id = db.Column(db.Integer,
nullable=False,
primary_key=True,
unique=True,
autoincrement=True)
text_content = db.Column(db.String(1000), nullable=False)
data_filename = db.Column(db.String(100), default=None, nullable=True)
# tag required to display
data_type = db.Column(db.String(100), default=None, nullable=True)
visibility = db.Column(db.Boolean, default=True, nullable=False)
timestamp = db.Column(
db.Integer,
nullable=False) # time since Unix Epoch (can be seconds granularity)
edit_timestamp = db.Column(db.Integer, default=None)
thread_id = db.Column(db.Integer, db.ForeignKey('pleep_threads.id'))
thread = db.relationship('Thread', back_populates='posts')
# Many (Posts) to One (User)
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
author = db.relationship('User', back_populates='myPosts')
# many likes to many users
likers = db.relationship('User', \
secondary=like_table, \
back_populates='liked')
like_count = db.Column(db.Integer, nullable=False, default=0)
def jsonify(self):
likerIDs = []
for l in self.likers:
likerIDs.append(l.id)
return {'id': self.id, \
'thread_id': self.thread_id, \
'thread_title': self.thread.title, \
'author_id': self.author_id, \
'author_name': self.author.name, \
'author_color': self.author.color, \
'timestamp': self.timestamp, \
'edit_timestamp': self.edit_timestamp, \
'thread_timestamp_close': self.thread.timestamp_close, \
'text_content': self.text_content, \
'data_filename': self.data_filename, \
'data_type' : self.data_type, \
'visibility': self.visibility, \
'likes': self.like_count, \
'likerIDs': likerIDs}
class DocumentoSedeModel(db.Model):
__tablename__ = 'dd_documento_sede'
#__table_args__ = {'schema':'UBBJ_01'}
id_documento = db.Column(db.Integer, primary_key=True)
id_sede = db.Column(db.Integer, nullable=False)
documento = db.Column(db.String(45), nullable=False)
url = db.Column(db.String(255), nullable=False)
b_estado = db.Column(db.Boolean, nullable=False)
def save_to_db(self):
db.session.add(self)
db.session.commit()
db.session.refresh(self)
class freeReducedLunch(db.Model):
id = db.Column(db.Integer, primary_key=True)
ncesid = db.Column(db.String(10))
numReducedLunch = db.Column(db.Integer)
numFreeLunch = db.Column(db.Integer)
def __init__(self, ncesid, numReducedLunch, numFreeLunch):
self.ncesid = ncesid
self.numReducedLunch = numReducedLunch
self.numFreeLunch = numFreeLunch
def __repr__(self):
return '<freeReducedLunch {}>'.format(self.ncesid)
class RevokedTokenModel(db.Model):
__tablename__ = 'revoked_tokens'
#__table_args__ = {'schema':'UBBJ_01'}
idToken = db.Column(db.Integer, primary_key=True)
jti = db.Column(db.String(120))
def add(self):
db.session.add(self)
db.session.commit()
@classmethod
def is_jti_blacklisted(cls, jti):
query = cls.query.filter_by(jti=jti).first()
return bool(query)
class estadoModel(db.Model):
__tablename__ = 'ci_estado'
id_estado = db.Column(db.Integer, primary_key=True)
estado = db.Column(db.String(45), nullable=False)
b_estado = db.Column(db.Boolean, nullable=False)
@classmethod
def return_all(cls):
def to_json(x):
return {'id_estado': x.id_estado, 'estado': x.estado}
return {
'Estados': list(map(lambda x: to_json(x), estadoModel.query.all()))
}
class acs5PlaceOfBirthByCitizenship(db.Model):
id = db.Column(db.Integer, primary_key=True)
censustractid = db.Column(db.String(10))
censustract = db.Column(db.String(10))
placeofbirth = db.Column(db.String(10))
count = db.Column(db.Integer)
def __init__(self, censustractid, censustract, placeofbirth, count):
self.censustractid = censustractid
self.censustract = censustract
self.placeofbirth = placeofbirth
self.count = count
def __repr__(self):
return '<acs5PlaceOfBirthByCitizenship {}>'.format(self.censustractid)
class acs5HouseholdIncomeByRace(db.Model):
id = db.Column(db.Integer, primary_key=True)
censustractid = db.Column(db.String(10))
censustract = db.Column(db.String(10))
householdincome = db.Column(db.String(10))
count = db.Column(db.Integer)
def __init__(self, censustractid, censustract, householdincome, count):
self.censustractid = censustractid
self.censustract = censustract
self.householdincome = householdincome
self.count = count
def __repr__(self):
return '<acs5HouseholdIncomeByRace {}>'.format(self.censustractid)
