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 Community(db.Model):
__tablename__ = "communities"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
description = 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)
posts = db.relationship("Post", back_populates="community")
def to_simple_dict(self):
return {
"id": self.id,
"name": self.name,
}
def to_dict(self):
return {
"id": self.id,
"name": self.name,
"description": self.description,
"created_at": self.created_at,
}
class User(UserMixin, db.Model, ModelMixin):
__tablename__ = "dashboard_users"
id = db.Column(db.BigInteger(), primary_key=True)
role = db.Column(db.String(255))
def __repr__(self):
return f"<id: {self.id}, role: {self.role}>"
class ItemOption(TimedBaseModel, ItemRelatedModel):
__tablename__ = "item_options"
id = db.Column(
db.Integer, autoincrement=True, primary_key=True, index=True, unique=True
)
price = db.Column(db.Float)
calculated_price = db.Column(db.Float)
condition = db.Column(sa.Enum(ItemCondition))
class Lot(TimedBaseModel, UserRelatedModel, ItemRelatedModel):
__tablename__ = "lots"
id = db.Column(
db.Integer, autoincrement=True, primary_key=True, index=True, unique=True
)
is_demand = db.Column(db.Boolean, default=expression.false())
price = db.Column(db.Integer)
status = db.Column(sa.Enum(LotStatus), default=LotStatus.created)
class Deal(TimedBaseModel, UserRelatedModel, LotRelatedModel):
__tablename__ = "deals"
id = db.Column(db.Integer,
autoincrement=True,
primary_key=True,
index=True,
unique=True)
type = db.Column(sa.Enum(DealType), default=DealType.lot_tax)
class Chat(TimedBaseModel):
__tablename__ = "chats"
id = db.Column(db.BigInteger, primary_key=True, index=True)
type = db.Column(db.String)
is_official = db.Column(db.Boolean, server_default=expression.false())
language = db.Column(db.String(12), default="en")
join_filter = db.Column(db.Boolean, server_default=expression.false())
class LocalizedItem(TimedBaseModel, ItemRelatedModel):
__tablename__ = "localized_items"
id = db.Column(
db.Integer, autoincrement=True, primary_key=True, index=True, unique=True
)
language = db.Column(db.String)
item_name = db.Column(db.String, index=True)
source_url = db.Column(db.String)
image_url = db.Column(db.String)
class WpAuthKey(db.Model):
__tablename__ = "wpti_proxy_tmp_keys"
id = db.Column(db.BigInteger(), primary_key=True)
creation_time = db.Column(db.DateTime, default=datetime.datetime.utcnow)
uuid = db.Column(db.String(60), nullable=False)
role = db.Column(db.String(255))
def __str__(self):
return "<Uuid: %s>" % self.uuid
class User(TimedBaseModel):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, index=True, unique=True)
is_superuser = db.Column(db.Boolean, server_default=expression.false())
start_conversation = db.Column(db.Boolean,
server_default=expression.false())
do_not_disturb = db.Column(db.Boolean,
default=False,
server_default=expression.false(),
nullable=False)
class Channel(TimedBaseModel):
__tablename__ = "channels"
id = db.Column(db.Integer, primary_key=True, index=True, unique=True)
chat_id = db.Column(db.String)
name = db.Column(db.String)
publications_counter_total = db.Column(db.Integer, default=0)
publications_counter_day = db.Column(db.Integer, default=0)
last_publication_datetime = db.Column(db.DateTime,
server_default=db.func.now())
count_of_publications = db.Column(db.Integer, default=1)
start_time_publications = db.Column(db.Time)
end_time_publications = db.Column(db.Time)
is_enable = db.Column(db.Boolean, server_default=expression.false())
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 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 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 ItemOptionRelatedModel(BaseModel):
__abstract__ = True
item_option_id = db.Column(
db.ForeignKey(
f"{ItemOption.__tablename__}.id", ondelete="CASCADE", onupdate="CASCADE"
),
nullable=False,
)
class LotRelatedModel(BaseModel):
__abstract__ = True
lot_id = db.Column(
db.ForeignKey(
f"{Lot.__tablename__}.id", ondelete="CASCADE", onupdate="CASCADE"
),
nullable=False,
)
class Tag(db.Model):
__tablename__ = "tags"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
description = db.Column(db.String(100), nullable=True)
created_at = db.Column(
db.DateTime, nullable=False, default=datetime.datetime.utcnow
)
updated_at = db.Column(
db.DateTime, nullable=False, default=datetime.datetime.utcnow
)
def to_dict(self):
return {
"id": self.id,
"name": self.name,
"description": self.description,
"created_at": self.created_at,
}
class Item(TimedBaseModel):
__tablename__ = "items"
id = db.Column(
db.Integer, autoincrement=True, primary_key=True, index=True, unique=True
)
product_id = db.Column(db.Integer, index=True)
source = db.Column(db.String)
original_name = db.Column(db.String, index=True)
set_name = db.Column(db.String, index=True)
card_type = db.Column(db.String)
rarity = db.Column(db.String)
finish = db.Column(db.String)
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 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 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 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 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,
}
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
class User(TimedBaseModel):
__tablename__ = "users"
user_id = db.Column(db.Integer, primary_key=True, index=True, unique=True)
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 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 User(TimedBaseModel):
__tablename__ = "users"
user_id = db.Column(db.Integer, primary_key=True, index=True, unique=True)
grade = db.Column(db.Integer)
subject = db.Column(db.String)
author = db.Column(db.String)
specification = db.Column(db.String)
year = db.Column(db.Integer)
main_topic = db.Column(db.String)
sub_topic = db.Column(db.String)
sub_sub_topic = db.Column(db.String)
exercise = db.Column(db.String)
is_blocked = db.Column(db.Boolean)
is_subscribed_to_notifications = db.Column(db.Boolean, default=True)
class New(db.Model):
__tablename__ = 'new'
id = db.Column(db.Integer, primary_key=True, index=True)
type = db.Column(db.String(30))
date = db.Column(db.DateTime, default=datetime.datetime.now())
title = db.Column(db.String(100))
pic = db.Column(db.String(200))
content = db.Column(db.String(5000))
def __init__(self, type, date, title, pic, content):
self.type = type
self.date = date
self.title = title
self.pic = pic
self.content = content
def __repr__(self):
return \
'<title %r, date %r>' % (
self.title, self.date)
def createNew(self, type, date, title, pic, content):
logging.info('Creando Noticia: %r' % title)
checkNewType = type in properties.newTypes
if checkNewType:
new = New(type, date, title, pic, content)
res = new.save()
logging.info('Noticia creada')
return res
else:
logging.info('Error al crear noticia')
return properties.responseNewInvalidType
def getNews(self, type):
logging.info("Obteniendo noticia")
result = self.query.filter(New.type.like(type)).all()
return result
def getNewById(self, id):
logging.info('Obteniendo noticia por id: %r' % id)
new = self.query.filter_by(id=id).first()
return new
def getNewsByDate(self, type, startDate, endDate):
logging.info('Obteniendo noticia por fecha: %r hasta %r ' %
(startDate, endDate))
if startDate is None:
news = self.query.filter(
and_(New.date <= endDate, New.type == type)).all()
else:
news = self.query.filter(
and_(New.date <= endDate, New.date >= startDate,
New.type == type)).all()
return news
def getNewsByTitle(self, type, title):
logging.info('Obteniendo noticia por titulo: %r' % title)
news = self.query.filter(
and_(New.name.like("%name%"), New.type == type)).all()
return news
def update(self):
try:
db.session.commit()
return properties.responseNewUpdated
except:
db.session.rollback()
return properties.responseNewNotUpdated
def save(self):
db.session.add(self)
try:
db.session.commit()
return properties.responseNewCreated
except:
db.session.rollback()
return properties.responseNewNotCreated
def delete(self):
try:
new = self.getBandById(self.id)
db.session.delete(new)
db.session.commit()
return properties.responseNewDeleted
except:
db.session.rollback()
return properties.responseNewNotDeleted
