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 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 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 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 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 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 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 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 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 Nagrada(db.Model):
__tablename__='Nagrada'
id=db.Column(db.Integer,primary_key=True,autoincrement=True)
naziv = db.Column(db.String(50))
iznos = db.Column(db.Float())
rank = db.Column(db.Integer)
korisnik_id = db.Column(db.Integer, db.ForeignKey('Korisnik.id'),nullable=True)
sponzor_id = db.Column(db.Integer, db.ForeignKey('Sponzor.id'),nullable=False)
kviz_id = db.Column(db.Integer, db.ForeignKey('Kviz.id'),nullable=False)
def __init__(self,naziv,iznos,rank,sponzor_id,kviz_id):
self.naziv=naziv
self.iznos=iznos
self.rank=rank
self.korisnik_id=None
self.sponzor_id = sponzor_id
self.kviz_id = kviz_id
def json(self):
return {
'id' : self.id,
'naziv' : self.naziv,
'iznos' : self.iznos,
'rank' : self.rank,
'dobitnik' : None if self.korisnik_id==None else Korisnik.vrati_korisnik(self.korisnik_id).json(),
'sponzor' : Sponzor.vrati_sponzor(self.sponzor_id).naziv
}
@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 update(self,korisnik_id):
self.korisnik_id=korisnik_id
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Grievance(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
category_grievance = db.Column(db.String(20), nullable=False)
title = db.Column(db.String(20), nullable=False)
content = db.Column(db.Text, nullable=False)
grievance_image_file = db.Column(db.String(20), nullable='False', default='default.jpg')
date_posted = db.Column(db.DateTime, nullable=False, default=datetime.now)
used_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Grievance('{self.category_grievance}', '{self.title}', '{self.content}', '{self.date_posted}')"
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 Post(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=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)
is_answered = db.Column(db.Boolean, default=False, nullable=False)
answers = db.relationship('Answer', backref='post', lazy=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}', '{self.author}')"
class Rezultat(db.Model):
__tablename__ = 'Rezultat'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
kviz_id = db.Column(db.Integer, db.ForeignKey('Kviz.id'), nullable=False)
korisnik_id = db.Column(db.Integer,
db.ForeignKey('Korisnik.id'),
nullable=False)
vrednost = db.Column(db.Float())
def __init__(self, kviz, korisnik, vrednost):
self.korisnik_id = korisnik
self.kviz_id = kviz
self.vrednost = vrednost
def json(self):
return {
'id': self.id,
'korisnik': self.korisnik_id,
'kviz': self.kviz_id,
'vrednost': self.vrednost,
}
@classmethod
def vrati_rezultate_za_kviz(cls, id):
return cls.query.filter_by(kviz_id=id)
@classmethod
def vrati_rezultate_za_korisnik(cls, id):
return cls.query.filter_by(korisnik_id=id)
@classmethod
def vrati_sve(cls):
return cls.query.all()
def add(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class PostAssoc(db.Model):
__tablename__ = 'user_to_post'
__table_args__ = (db.PrimaryKeyConstraint('user_id', 'post_id'), )
user_id = db.Column(db.Integer, db.ForeignKey('users.id')) # nullable?
user = db.relationship('User', back_populates='active_posts')
post_id = db.Column(db.Integer, db.ForeignKey('posts.id'))
post = db.relationship('Post')
# metadata
# postAssocs are made by followees creating posts
# postAssocs are removed by...? timeout?
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,
'post_id': self.post_id,
'state': self.state
}
class Thread(db.Model):
__tablename__ = 'pleep_threads'
id = db.Column(db.Integer,
nullable=False,
primary_key=True,
unique=True,
autoincrement=True)
title = db.Column(db.String(100), nullable=False)
categories = db.Column(db.String(1000)) # csv of 'hashtags'
timestamp = db.Column(db.Integer, nullable=False)
timestamp_close = db.Column(db.Integer)
timestamp_delete = db.Column(db.Integer)
closed = db.Column(db.Boolean, nullable=False, default=False)
# back ref to display user info easier
creator_id = db.Column(db.Integer, db.ForeignKey('users.id'))
creator = db.relationship("User", back_populates='myThreads')
# One (Thread) to Many (Posts)
posts = db.relationship('Post', back_populates='thread')
total_likes = db.Column(db.Integer, nullable=False, default=0)
# permissions work best with a friends list, otherwise private list
# requires knowing all other user's names?
# unless it queries for all usernames and filters in realtime for autocomplete
read_access = db.Column(db.Boolean, nullable=False, default=True)
write_access = db.Column(db.Boolean, nullable=False, default=True)
permission_list = db.Column(db.String(1000), nullable=False,
default='') # csv?
# generate list of post ids
def jsonify(self):
postIDs = []
for p in self.posts:
postIDs.append(p.id)
return {'id': self.id, \
'title': self.title, \
'categories': self.categories, \
'timestamp': self.timestamp, \
'timestamp_close': self.timestamp_close, \
'timestamp_delete': self.timestamp_delete, \
'closed': self.closed, \
'creator': self.creator.name, \
'creator_id': self.creator_id, \
'postCount': len(self.posts), \
'postIDs': postIDs, \
'total_likes': self.total_likes}
class Upload(db.Model):
__tablename__ = 'upload'
id = db.Column('id', db.Integer, primary_key=True)
title = db.Column('title', db.String(30))
category = db.Column('category', db.String(30))
description = db.Column('description', db.String(600))
price = db.Column('price', db.Integer)
upload_ref = db.Column('upload_ref', db.VARCHAR)
timestamp = db.Column(db.DateTime, default=datetime.datetime.utcnow)
user_id = db.Column('user_id', db.Integer, db.ForeignKey('user.id'), nullable=False)
comments = db.relationship('Comment', backref='upload', lazy='dynamic')
def __repr__(self, id, title, category, description, price, upload_ref, user_id):
self.id = id
self.title = title
self.category = category
self.description = description
self.price = price
self.upload_ref = upload_ref
self.user_id = user_id
class OdgovorModel(db.Model):
__tablename__='odgovori'
id=db.Column(db.Integer,primary_key=True)
datum=db.Column(db.DateTime)
email=db.Column(db.String)
primalac=db.Column(db.String)
naslov=db.Column(db.String)
sadrzaj=db.Column(db.String)
poruka=db.Column(db.Integer,db.ForeignKey('poruke.id'))
def __init__(self,sadrzaj,primalac,naslov,poruka):
self.datum=datetime.now()
self.primalac=primalac
self.naslov=naslov
self.email='*****@*****.**'
self.sadrzaj=sadrzaj
self.poruka=poruka
def json(self):
return {
'id':self.id,
'datum':self.datum,
'email':self.email,
'primalac':self.primalac,
'naslov':self.naslov,
'sadrzaj':self.sadrzaj,
'poruka':self.poruka
}
@classmethod
def find_all(cls):
return cls.query.all()
@classmethod
def find_odgovorNaPoruku(cls,porukaID):
return cls.query.filter_by(poruka=porukaID).first()
def add(self):
db.session.add(self)
db.session.commit()
class Item(db.Model):
"""Items are the objects stored in containers"""
id = db.Column(db.Integer, primary_key=True)
inventoryId = db.Column(db.Integer,
db.ForeignKey('inventory.id'),
primary_key=True)
name = db.Column(db.String(200))
quantity = db.Column(db.Integer)
purchaseDate = db.Column(db.Date)
expirationDate = db.Column(db.Date)
purchasePrice = db.Column(db.Float)
inventory = db.relationship('Inventory')
def __init__(self,
inventoryId,
name,
quantity=1,
purchaseDate=None,
expirationDate=None,
purchasePrice=None):
self.inventoryId = inventoryId
self.name = name
self.quantity = quantity
self.purchaseDate = purchaseDate
self.expirationDate = expirationDate
self.purchasePrice = purchasePrice
def serialize(self):
return {
'id': self.id,
'inventoryId': self.inventoryId,
'name': self.name,
'quantity': self.quantity,
'purchaseDate': serialize_date(self.purchaseDate),
'expirationDate': serialize_date(self.expirationDate),
'purchasePrice': self.purchasePrice
}
class Follow(db.Model):
__tablename__ = 'follows'
follower_id = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True)
followed_id = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True)
timestamp = db.Column(db.DateTime, default=datetime.datetime.utcnow)
from flaskApp import db
# use imports from db instead of sqlalchemy base
# ids generated by uuid4 (?)
follow_table = db.Table(
'follow_association', db.metadata,
db.Column('followee_id', db.Integer, db.ForeignKey('users.id')),
db.Column('follower_id', db.Integer, db.ForeignKey('users.id')))
like_table = db.Table(
'like_association', db.metadata,
db.Column('user_id', db.Integer, db.ForeignKey('users.id')),
db.Column('post_id', db.Integer, db.ForeignKey('posts.id')))
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer,
primary_key=True,
unique=True,
autoincrement=True)
name = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(100), unique=False, nullable=False)
address = db.Column(db.String(50))
color = db.Column(db.String(8), default='#000000')
admin = db.Column(db.Boolean, nullable=False, default=False)
clout = db.Column(db.Integer, default=0, nullable=False)
#clout_static = db.Column(db.Integer, default=0, nullable=False)
lifetime_pleeps = db.Column(db.Integer, default=0)
import datetime
from flask_login import UserMixin
from flaskApp import login_manager, db
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
import psycopg2
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
followers = db.Table('followers',
db.Column('follower_id', db.Integer, db.ForeignKey('user.id')),
db.Column('followed_id', db.Integer, db.ForeignKey('user.id')))
book = db.Table('book',
db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
db.Column('post_id', db.Integer, db.ForeignKey('post.id')))
likes = db.Table('likes',
db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
db.Column('upload_id', db.Integer, db.ForeignKey('upload.id')))
class User(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column('id', db.Integer, primary_key=True)
role = db.Column('role', db.Integer, default=0)
"""
from datetime import datetime
from flaskApp import db
from werkzeug.security import generate_password_hash, check_password_hash
from flask_login import UserMixin
from flaskApp import login
from hashlib import md5
followers = db.Table(
'followers', db.Column('follower_id', db.Integer,
db.ForeignKey('user.id')),
db.Column('followed_id', db.Integer, db.ForeignKey('user.id')))
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))
posts = db.relationship('Post', backref='author', lazy='dynamic')
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
followed = db.relationship('User',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
