class Message(db.Model):
__tablename__ = "messages"
id = db.Column(db.Integer, primary_key=True)
sender_id = db.Column(db.Integer,
db.ForeignKey("users.id"),
nullable=False)
recipient_id = db.Column(db.Integer,
db.ForeignKey("users.id"),
nullable=False)
body = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.utcnow)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.utcnow)
sender = db.relationship("User",
foreign_keys=[sender_id],
back_populates="sent_messages")
recipient = db.relationship("User",
foreign_keys=[recipient_id],
back_populates="received_messages")
def to_dict(self):
return {
"id": self.id,
"sender": MinimalUserResponse.from_orm(self.sender).dict(),
"recipient": MinimalUserResponse.from_orm(self.recipient).dict(),
"created_at": self.created_at,
}
class PostRating(db.Model):
__tablename__ = "post_ratings"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
post_id = db.Column(db.Integer, db.ForeignKey("posts.id"), nullable=False)
rating = db.Column(db.Integer, nullable=False)
created_at = db.Column(
db.DateTime, nullable=False, default=datetime.datetime.utcnow
)
updated_at = db.Column(
db.DateTime, nullable=False, default=datetime.datetime.utcnow
)
user = db.relationship("User")
post = db.relationship("Post", back_populates="ratings")
def to_simple_dict(self):
return {
"user_id": self.user_id,
"rating": self.rating,
}
def to_dict(self):
return {
"id": self.id,
"user": MinimalUserResponse.from_orm(self.user).dict(),
"post": self.post.to_simple_dict(),
"rating": self.rating,
}
class Post(TimedBaseModel):
__tablename__ = "posts"
id = db.Column(db.Integer, primary_key=True, index=True, unique=True)
donor_id = db.Column(db.Integer, db.ForeignKey('donors.id'))
channel_id = db.Column(db.Integer, db.ForeignKey('channels.id'))
title = db.Column(db.String)
photo = db.Column(db.ARRAY(db.String))
video = db.Column(db.ARRAY(db.String))
type = db.Column(db.String, default=0)
publication_date = db.Column(db.DateTime)
is_enable = db.Column(db.Boolean, server_default=expression.false())
class UserRelatedModel(BaseModel):
__abstract__ = True
user_id = db.Column(
db.ForeignKey(f"{User.__tablename__}.id", ondelete="CASCADE", onupdate="CASCADE"),
nullable=False
)
class Photo(TimedBaseModel):
__tablename__ = "photos"
id = db.Column(db.Integer, primary_key=True, index=True, unique=True)
url = db.Column(db.String)
photo_id = db.Column(db.String)
solution_id = db.Column(db.Integer, db.ForeignKey("solutions.id"))
class Meetup(db.Model):
__tablename__ = "meetups"
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(50), nullable=False)
description = db.Column(db.Text, nullable=False)
city = db.Column(db.String(50), nullable=False)
state = db.Column(db.String(25), nullable=False)
lat = db.Column(db.Numeric(scale=7))
lng = db.Column(db.Numeric(scale=7))
date = db.Column(db.DateTime, nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.utcnow)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.utcnow)
user = db.relationship("User", back_populates="meetups")
def to_dict(self):
return {
"id": self.id,
"user": MinimalUserResponse.from_orm(self.user).dict(),
"name": self.name,
"description": self.description,
"city": self.city,
"state": self.state,
"lat": float(self.lat or 0),
"lng": float(self.lng or 0),
"date": self.date,
"created_at": self.created_at,
"updated_at": self.updated_at,
}
class LotRelatedModel(BaseModel):
__abstract__ = True
lot_id = db.Column(
db.ForeignKey(
f"{Lot.__tablename__}.id", ondelete="CASCADE", onupdate="CASCADE"
),
nullable=False,
)
class ItemOptionRelatedModel(BaseModel):
__abstract__ = True
item_option_id = db.Column(
db.ForeignKey(
f"{ItemOption.__tablename__}.id", ondelete="CASCADE", onupdate="CASCADE"
),
nullable=False,
)
class Donor(TimedBaseModel):
__tablename__ = "donors"
id = db.Column(db.Integer, primary_key=True, index=True, unique=True)
type = db.Column(db.String)
name = db.Column(db.String)
link = db.Column(db.String)
parsing_rate = db.Column(db.Integer, default=0)
is_enable = db.Column(db.Boolean, server_default=expression.false())
channel_id = db.Column(db.Integer, db.ForeignKey('channels.id'))
class Retailer(db.Model):
__tablename__ = "retailers"
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(50), nullable=False)
description = db.Column(db.Text, nullable=False)
city = db.Column(db.String(50), nullable=False)
state = db.Column(db.String(25), nullable=False)
lat = db.Column(db.Numeric(scale=7))
lng = db.Column(db.Numeric(scale=7))
created_at = db.Column(
db.DateTime, nullable=False, default=datetime.datetime.utcnow
)
updated_at = db.Column(
db.DateTime, nullable=False, default=datetime.datetime.utcnow
)
user = db.relationship("User", back_populates="retailers")
images = db.relationship("RetailerImage", back_populates="retailer")
ratings = db.relationship("RetailerRating", back_populates="retailer")
def to_dict(self):
return {
"id": self.id,
"owner": MinimalUserResponse.from_orm(self.user).dict(),
"name": self.name,
"description": self.description,
"city": self.city,
"state": self.state,
"lat": float(self.lat or 0),
"lng": float(self.lng or 0),
"created_at": self.created_at,
"images": [image.image_url for image in self.images],
"ratings": {rating.user_id: rating.to_dict() for rating in self.ratings},
}
def to_simple_dict(self):
return {
"id": self.id,
"owner": MinimalUserResponse.from_orm(self.user).dict(),
"name": self.name,
"description": self.description,
"city": self.city,
"state": self.state,
"created_at": self.created_at,
"ratings": [rating.to_dict() for rating in self.ratings],
}
class Thread(db.Model):
__tablename__ = "threads"
id = db.Column(db.Integer, primary_key=True)
post_id = db.Column(db.Integer, db.ForeignKey("posts.id"), nullable=False)
comments = db.relationship("Comment", back_populates="thread")
post = db.relationship("Post", back_populates="threads")
def to_dict(self):
return {
"id": self.id,
"comments": {
comment.id: comment.to_simple_dict() for comment in self.comments
},
"post_id": self.post_id,
}
class PostsImage(db.Model):
__tablename__ = "posts_images"
id = db.Column(db.Integer, primary_key=True)
post_id = db.Column(db.Integer, db.ForeignKey("posts.id"), nullable=False)
image_url = db.Column(db.String, nullable=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
post = db.relationship("Post", back_populates="images")
def to_dict(self):
return {
"id": self.id,
"post_id": self.post_id,
"image_url": self.image_url,
"created_at": self.created_at,
"updated_at": self.updated_at,
"post": self.post.to_dict(),
}
class RetailerImage(db.Model):
__tablename__ = "retailer_images"
id = db.Column(db.Integer, primary_key=True)
retailer_id = db.Column(db.Integer,
db.ForeignKey("retailers.id"),
nullable=False)
image_url = db.Column(db.String, nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.utcnow)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.utcnow)
retailer = db.relationship("Retailer", back_populates="images")
def to_dict(self):
return {
"id": self.id,
"retailer_id": self.retailer_id,
"image_url": self.image_url,
"created_at": self.created_at,
}
from app.models.db import db
saved_posts = db.Table(
"saved_posts",
db.Model.metadata,
db.Column("user_id", db.Integer, db.ForeignKey("users.id")),
db.Column("post_id", db.Integer, db.ForeignKey("posts.id")),
)
class Comment(db.Model):
__tablename__ = "comments"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
thread_id = db.Column(db.Integer,
db.ForeignKey("threads.id"),
nullable=False)
comment_id = db.Column(db.Integer,
db.ForeignKey("comments.id"),
nullable=True)
path = db.Column(db.String(255), nullable=False)
level = db.Column(db.Integer, nullable=False)
body = db.Column(db.Text, nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.utcnow)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.utcnow)
thread = db.relationship("Thread", back_populates="comments")
user = db.relationship("User", back_populates="comments")
children = db.relationship("Comment",
backref=db.backref("parent", remote_side=[id]))
ratings = db.relationship("CommentRating", back_populates="comment")
def to_simple_dict(self):
return {
"id": self.id,
"body": self.body,
"user": MinimalUserResponse.from_orm(self.user).dict(),
"comment_id": self.comment_id,
}
def to_search_dict(self):
return {
"id": self.id,
"body": self.body,
"user": MinimalUserResponse.from_orm(self.user).dict(),
"post": self.thread.post.to_search_dict(),
"ratings":
{rating.user_id: rating.to_dict()
for rating in self.ratings},
"created_at": self.created_at,
}
def to_dict(self):
return {
"id": self.id,
"user": MinimalUserResponse.from_orm(self.user).dict(),
"body": self.body,
"thread_id": self.thread_id,
"path": self.path,
"level": self.level,
"created_at": self.created_at,
"updated_at": self.updated_at,
"children": [child.to_simple_dict() for child in self.children],
"ratings":
{rating.user_id: rating.to_dict()
for rating in self.ratings},
"post": self.thread.post.to_search_dict(),
}
class Band(db.Model):
__tablename__ = 'band'
id = db.Column(db.Integer, primary_key=True, index=True)
name = db.Column(db.String(30)) #not null
state = db.Column(db.Integer, db.ForeignKey('state.id')) #not null
pic = db.Column(db.String(200))
review = db.Column(db.String(5000))
def __init__(self, name, state):
self.name = name
self.state = state
def __repr__(self):
return \
'<name %r, state %r' % (
self.name, self.state)
def createBand(self, name, state):
logging.info('Creando Banda: %r' % name)
checkBandName = len(name) <= properties.maxBandName
if checkBandName:
band = Band(name, state)
logging.info('Banda creada')
return band.save()
else:
logging.info("Error creando banda")
return properties.responsaBandNotCreated
def getBands(self):
logging.info("Obteniendo bandas")
result = self.query.all()
return result
def getBandsByStateId(self, state):
logging.info('Obteniendo bandas por estado: %r' % state)
bands = self.query.filter_by(state=state).all()
return bands
def getBandsByName(self, name):
logging.info('Obteniendo bandas por nombre: %r' % name)
bands = self.query.filter(Band.name.like("%name%")).all()
return bands
def getBandById(self, id):
logging.info('Obteniendo banda por id: %r' % id)
band = self.query.filter_by(id=id).first()
return band
def setBandPic(self, pic):
self.pic = pic
def setBandReview(self, review):
self.review = review
def update(self):
try:
db.session.commit()
return properties.responseBandUpdated
except:
db.session.rollback()
return properties.responseBandNotUpdated
def save(self):
try:
db.session.add(self)
db.session.commit()
return properties.responseBandCreated
except:
db.session.rollback()
return properties.responseBandNotCreated
def delete(self):
try:
band = self.getBandById(self.id)
db.session.delete(band)
db.session.commit()
return properties.responseBandDeleted
except:
db.session.rollback()
return properties.responseBandNotDeleted
from app.models.db import db
saved_comments = db.Table(
"saved_comments",
db.Model.metadata,
db.Column("user_id", db.Integer, db.ForeignKey("users.id"),
nullable=False),
db.Column("comment_id",
db.Integer,
db.ForeignKey("comments.id"),
nullable=False),
)
class Disc(db.Model):
__tablename__ = 'disc'
id = db.Column(db.Integer, primary_key=True, index=True)
name = db.Column(db.String(60)) #not null
date = db.Column(db.DateTime, default=datetime.datetime.now()) #not null
genre = db.Column(db.String(60)) #not null
score = db.Column(db.Integer)
band = db.Column(db.Integer, db.ForeignKey('band.id')) #not null
cover = db.Column(db.String(200))
review = db.Column(db.String(5000))
def __init__(self, name, date, genre, band):
self.name = name
self.date = date
self.genre = genre
self.band = band
self.score = 0
def __repr__(self):
return \
'<date %r, name %r, band %r >' % (
self.date, self.name, self.band)
def createDisc(self, name, date, genre, band):
logging.info("Creando disco")
checkLongName = len(name) <= properties.maxDiscName
checkGenre = len(genre) <= properties.maxGenreName
if checkLongName and checkGenre:
disc = Disc(name, date, genre, band)
logging.info("Disco creado")
return disc.save()
else:
logging.info("Error creando disco")
return properties.responseDiscNotCreated
def getDiscs(self):
logging.info("Obteniendo discos")
result = self.query.all()
return result
def getDiscsByDate(self, startDate, endDate):
logging.info('Obteniendo discos por fecha: %r hasta %r ' %
(startDate, endDate))
if startDate is None:
discs = self.query.filter(Disc.date <= endDate).all()
else:
discs = self.query.filter(
and_(Disc.date <= endDate, Disc.date >= startDate)).all()
return discs
def getDiscsByGenre(self, genre):
logging.info('Obteniendo discos por genero: %r' % genre)
discs = self.query.filter_by(genre=genre).all()
return discs
def getDiscsByScore(self, startScore, endScore):
logging.info('Obteniendo discos por puntuacion: %r hasta %r ' %
(startScore, endScore))
if startScore is None:
discs = self.query.filter(Disc.score <= endScore).all()
else:
discs = self.query.filter(
and_(Disc.score <= endScore, Disc.score >= startScore)).all()
return discs
def getDiscsByBand(self, band):
logging.info('Obteniendo discos por banda: %r' % band)
discs = self.query.filter_by(band=band).all()
return discs
def getDiscsByName(self, name):
logging.info('Obteniendo discos por nombre: %r' % name)
bands = self.query.filter(Disc.name.like("%" + name + "%")).all()
return bands
def getDiscById(self, id):
logging.info('Obteniendo disco por id: %r' % id)
disc = self.query.filter_by(id=id).first()
return disc
def setDiscScore(self, score):
self.score = score
def setDiscCover(self, cover):
self.cover = cover
def setDiscGenre(self, genre):
self.genre = genre
def setDiscReview(self, review):
self.review = review
def update(self):
try:
db.session.commit()
return properties.responseDiscUpdated
except:
db.session.rollback()
return properties.responseDiscNotUpdated
def save(self):
db.session.add(self)
try:
db.session.commit()
return properties.responseDiscCreated
except:
db.session.rollback()
return properties.responseDiscNotCreated
def delete(self):
try:
disc = self.getDiscById(self.id)
db.session.delete(disc)
db.session.commit()
return properties.responseDiscDeleted
except:
db.session.rollback()
return properties.responseDiscNotDeleted
from app.models.db import db
posts_tags = db.Table(
"posts_tags",
db.Model.metadata,
db.Column("post_id", db.Integer, db.ForeignKey("posts.id")),
db.Column("tag_id", db.Integer, db.ForeignKey("tags.id")),
)
