class UsuarioEntidade(db.Model):
__tablename__= 'usuario_entidade'
id = db.Column(db.Integer, primary_key=True)
usuario_id = db.Column(db.Integer, db.ForeignKey('usuarios.id'))
entidade_id = db.Column(db.Integer, db.ForeignKey('entidades.id'))
usuario = db.relationship(UsuarioModel, backref=db.backref("usuario_assoc"))
entidade = db.relationship(Entidade, backref=db.backref("entidade_assoc"))
class UsuarioEntidade(db.Model):
__tablename__ = 'assinatura_aplicativo'
id = db.Column(db.Integer, primary_key=True)
assinatura_id = db.Column(db.Integer, db.ForeignKey('assinaturas.id'))
aplicativo_id = db.Column(db.Integer, db.ForeignKey('aplicativos.id'))
assinatura = db.relationship(Assinatura,
backref=db.backref("assinatura_assoc"))
aplicativo = db.relationship(Aplicativo,
backref=db.backref("aplicativo_assoc"))
class TestRun(db.Model):
__tablename__ = 'testruns'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), index=True)
timestamp = db.Column(db.DateTime, default=datetime.date.today())
waved = db.Column(db.Boolean)
operatingsystem_id = db.Column(
db.Integer, db.ForeignKey('operatingsystems.id'))
operatingsystem = db.relationship(
'OperatingSystem',
backref=db.backref('testruns', lazy='dynamic'),
)
project_id = db.Column(
db.Integer, db.ForeignKey('projects.id'))
project = db.relationship(
'Project',
backref=db.backref('testruns', lazy='dynamic'),
)
release_id = db.Column(
db.Integer, db.ForeignKey('releases.id'))
release = db.relationship(
'Release',
backref=db.backref('testruns', lazy='dynamic'),
)
passed = db.Column(db.Integer)
failed = db.Column(db.Integer)
skipped = db.Column(db.Integer)
error = db.Column(db.Integer)
total = db.Column(db.Integer)
total_executed = db.Column(db.Integer)
percent_passed = db.Column(db.Float)
percent_failed = db.Column(db.Float)
percent_executed = db.Column(db.Float)
percent_not_executed = db.Column(db.Float)
notes = db.Column(db.Text)
def update_stats(self):
self.total = sum([self.passed, self.failed, self.skipped, self.error])
self.total_executed = sum([self.passed, self.failed])
self.percent_passed = (
(self.passed / float(self.total_executed)) * 100
if self.total_executed > 0
else 0)
self.percent_failed = (
(self.failed / float(self.total_executed)) * 100
if self.total_executed > 0
else 0)
self.percent_executed = (
(self.total_executed / float(self.total)) * 100
if self.total > 0
else 0)
self.percent_not_executed = (
(self.skipped / float(self.total)) * 100 if self.total > 0 else 0)
class Regions(db.Model):
__tablename__ = 'regions'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
parent_id = db.Column(db.Integer, nullable=False, unique=True)
cities = db.relationship('Cities', backref=db.backref('region', cascade="all, delete"), lazy=True)
class Product(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
price = db.Column(db.Numeric, nullable=False)
quantity = db.Column(db.Integer, nullable=False)
category_id = db.Column(db.Integer,
db.ForeignKey('category.id'),
nullable=False)
category = db.relationship('Category',
backref=db.backref('products', lazy=True))
def save(self):
db.session.add(self)
db.session.commit()
@classmethod
def find(cls, name):
return cls.query.outerjoin(Category).filter((
Category.name.contains(name)) | (cls.name.contains(name))).all()
@classmethod
def find_by_category_name(cls, name):
return cls.query.outerjoin(Category).filter(
Category.name.contains(name)).all()
class Channel(db.Model):
__tablename__ = "channels"
chnl_no = db.Column(db.String(12), primary_key=True)
chnl_name = db.Column(db.String(200), nullable=False)
chnl_cat_1 = db.Column(db.SmallInteger, nullable=False)
chnl_cat_2 = db.Column(db.SmallInteger, nullable=False)
chnl_cat_3 = db.Column(db.SmallInteger, nullable=False)
# 经纬度，默认 -1，表示非线下渠道
longitude = db.Column(db.String(20), nullable=False, default='-1')
latitude = db.Column(db.String(20), nullable=False, default='-1')
contract_life = db.Column(db.Date, nullable=False)
# 归属分公司，线上渠道是否不归属于分公司？（可使用默认值0）
city_code = db.Column(db.String(8),
nullable=False,
index=True,
default='0')
# 下一层级渠道
sub_channels = db.relationship(
# 关联的模型，自关联
'Channel',
# 关联的表，定义的 channel_relation 表，存储各个渠道之间的关系
secondary='channel_relation',
primaryjoin=(channel_relation.c.sup_chnl_no == chnl_no),
secondaryjoin=(channel_relation.c.sub_chnl_no == chnl_no),
backref=db.backref('sup_channel', lazy='dynamic'),
lazy='dynamic')
class Token(db.Model):
__table_args__ = ({
'mysql_character_set': 'utf8mb4',
'mysql_collate': 'utf8mb4_unicode_520_ci'
})
id = Column('id', Integer, primary_key=True)
token = Column('token', String(80), unique=True, nullable=False)
user_id = Column('user', Integer, ForeignKey('user.id'), nullable=False)
user = db.relationship('User', backref=db.backref('users', lazy=True))
created = Column('created', DateTime, nullable=False)
expires = Column('expires', DateTime)
broken = Column('broken', Boolean, nullable=False)
def __init__(self, *args, **kwargs):
expires = datetime.now() + timedelta(
hours=current_app.config['TOKEN_VALIDITY'])
super().__init__(*args,
**kwargs,
token=str(uuid4()),
created=datetime.utcnow(),
expires=expires,
broken=False)
def jsonify(self):
return {
'token': self.token,
'user': self.user.jsonify(),
'valid': self.broken == 0 and self.expires > datetime.utcnow()
}
def is_valid(self):
return self.broken == 0 and self.expires > datetime.utcnow()
class Message(db.Model):
__table_args__ = ({
'mysql_character_set': 'utf8mb4',
'mysql_collate': 'utf8mb4_unicode_520_ci'
})
id = Column('id', Integer, primary_key=True)
subject = Column('subject', String(80), unique=True, nullable=False)
message = Column('message', String(1000), nullable=False)
created = Column('created', DateTime)
user_id = Column('user', Integer, ForeignKey('user.id'), nullable=False)
user = db.relationship('User', backref=db.backref('message', lazy=True))
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs, created=datetime.utcnow())
def jsonify(self):
return {
'id': self.id,
'subject': self.subject,
'message': self.message,
'created': self.created.strftime("%d.%m.%Y %H:%M:%S"),
'user': self.user.jsonify()
}
class Article(db.Model):
__tablename__ = 'articles'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255), nullable=False)
source = db.Column(db.String(255), nullable=False)
date = db.Column(db.DateTime, nullable=False)
url = db.Column(db.String(255), nullable=False)
author = Column(Integer, ForeignKey("authors.id"))
sentences_count = db.Column(db.Integer)
shares_count = db.Column(db.Integer)
keywords = db.relationship(
'Keyword',
secondary=articles_keywords,
primaryjoin=(articles_keywords.c.article_id == id),
backref=db.backref('articles', lazy='dynamic'),
lazy='dynamic')
def __init__(self, title, source, date, url, sentences_count) -> None:
self.title = title
self.source = source
self.date = date
self.url = url
self.sentences_count = sentences_count
def __repr__(self) -> Text:
return '<title {}'.format(self.title)
class TestCase(db.Model):
__tablename__ = 'testcases'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), index=True, unique=True)
type_id = db.Column(db.Integer, db.ForeignKey('testtypes.id'))
type = db.relationship(
'TestType',
backref=db.backref('testcases', lazy='dynamic'),
)
category_id = db.Column(db.Integer, db.ForeignKey('categories.id'))
category = db.relationship(
'Category',
backref=db.backref('testcases', lazy='dynamic'),
)
def __repr__(self):
return '<Test Case {0}>'.format(self.name)
class Order(db.Model):
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime, nullable=False)
address = db.Column(db.String(255), nullable=False)
customer_id = db.Column(db.String(255),
db.ForeignKey('customer.id'),
nullable=False)
customer = db.relationship('Customer',
backref=db.backref('orders', lazy=True))
class Client(TimeStampMixin, CreateMixin, db.Model):
name = db.Column(db.String(120), nullable=False, unique=True)
id = db.Column(db.Integer, primary_key=True)
feature_requests = db.relationship('FeatureRequest',
backref=db.backref('client',
lazy='select'),
uselist=False)
def __repr__(self):
return '<Client name: {} id: {} >'.format(self.name, self.id)
class Solve(db.Model):
__table_args__ = ({'mysql_character_set': 'utf8mb4', 'mysql_collate': 'utf8mb4_unicode_520_ci'})
id = Column('id', Integer, primary_key=True)
user_id = Column('user', Integer, ForeignKey('user.id'), nullable=False)
user = db.relationship('User', backref=db.backref('solves', lazy=True))
challenge_id = Column('challenge', Integer, ForeignKey('challenge.id'), nullable=False)
challenge = db.relationship('Challenge', backref=db.backref('solves', lazy=True))
timestamp = Column('created', DateTime, nullable=False)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs, timestamp=datetime.utcnow())
def jsonify(self):
# TODO check points (DownloadPizza reported that the points on account page are not correct)
return {
'challenge': self.challenge.min_jsonify(),
'timestamp': self.timestamp
}
class Registration(db.Model):
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.Text(), unique=True)
blob = db.Column(db.Text())
_priority = db.Column("priority", db.Integer())
_confirmed = db.Column("confirmed", db.Boolean())
uni_id = db.Column(db.Integer(), db.ForeignKey("uni.id"))
uni = db.relationship(
"Uni",
backref=db.backref("Registrations",
lazy="dynamic",
cascade="all, delete-orphan"),
)
@property
def user(self):
return User.get(self.username)
@property
def is_guaranteed(self):
return any(
map(self.user.is_in_group,
current_app.config["ZAPF_GUARANTEED_GROUPS"]))
@property
def confirmed(self):
return self._confirmed or self.is_guaranteed
@confirmed.setter
def confirmed(self, value):
if not self.is_guaranteed:
self._confirmed = value
@property
def priority(self):
return self._priority if not self.is_guaranteed else -1
@priority.setter
def priority(self, value):
self._priority = value if not self.is_guaranteed else None
@property
def data(self):
return json.loads(self.blob)
@data.setter
def data(self, value):
self.blob = json.dumps(value)
@property
def is_zapf_attendee(self):
return self.confirmed and self.priority < self.uni.slots
class Issue(db.Model):
__tablename__ = 'issues'
id = db.Column(db.Integer, primary_key=True)
tracker_id = db.Column(db.Integer, db.ForeignKey('testtrackers.id'))
tracker = db.relationship(
'TestTracker',
backref=db.backref('testtrackers', lazy='dynamic'),
)
number = db.Column(db.String(30), index=True)
def __repr__(self):
return '<Issue {0}>'.format(self.number)
class ClassifiedAd(db.Model, CRUDMixin, TimestampMixin):
__tablename__ = 'classified_ad'
name = db.Column(db.String(255), nullable=False)
description = db.Column(db.Text)
publisher = db.Column(db.String(255), nullable=False)
phone = db.Column(db.String(80))
email = db.Column(db.String(255))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
image = db.Column(db.LargeBinary)
categories = db.relationship('ClassifiedTags',
secondary='ads_tags_rel',
lazy='subquery',
backref=db.backref('ads', lazy=True))
class UserInfo(db.Model):
__tablename__ = 'userinfo'
id = db.Column(db.Integer, primary_key = True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = relationship('User', backref=db.backref('user_info', lazy='dynamic'))
spectrum = db.Column('spectrum', db.Integer())
user_story = db.Column('user_story', db.String())
goal = db.Column('goal', db.String())
def __init__(self, user, spectrum, user_story, goal):
self.user = user
self.spectrum = spectrum
self.user_story = user_story
self.goal = goal
class Rating(db.Model):
__table_args__ = ({
'mysql_character_set': 'utf8mb4',
'mysql_collate': 'utf8mb4_unicode_520_ci'
})
id = Column('id', Integer, primary_key=True)
user_id = Column('user', Integer, ForeignKey('user.id'), nullable=False)
user = db.relationship('User', backref=db.backref('Rating', lazy=True))
challenge_id = Column('challenge',
Integer,
ForeignKey('challenge.id'),
nullable=False)
challenge = db.relationship('Challenge',
backref=db.backref('Rating', lazy=True))
thumb_up = Column('thumbUp', Boolean, nullable=False)
created = Column('created', DateTime, nullable=False)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs, created=datetime.utcnow())
class Rol(db.Model):
__tablename__ = 'rol'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String)
permisos = db.relationship('Permiso',
secondary=permisos,
backref=db.backref('roles_con_el_permiso',
lazy=True),
lazy='subquery')
def get_by_nombre(nombre_rol):
return Rol.query.filter_by(nombre=nombre_rol).first()
def all():
return Rol.query.all()
class Mascot(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.Text(), unique=False)
uni_id = db.Column(db.Integer(), db.ForeignKey('uni.id'))
uni = db.relationship('Uni',
backref=db.backref('Mascots',
lazy='dynamic',
cascade="all, delete-orphan"))
def __init__(self, name, uni_id):
self.name = name
self.uni_id = uni_id
def __repr__(self):
return "<Mascot: {}>".format(self.name)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role', secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def __str__(self):
return self.email
def set_password(self, password):
self.password = encrypt_password(password)
class Reviewer(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60), nullable=False)
surname = db.Column(db.String(60), nullable=False)
email = db.Column(db.String(120), nullable=False)
description = db.Column(db.String(500), nullable=True)
repository_url = db.Column(db.String(500), nullable=False)
technologies = db.relationship('Technology',
secondary='reviewer_technology',
lazy=False,
backref=db.backref('reviewers', lazy=True))
def is_valid(self):
if len(self.technologies) == 0:
return False
for technology in self.technologies:
if technology is None:
return False
return self.name != '' and self.surname != '' and self.email != ''
def format(self):
technologies = [tech.format() for tech in self.technologies]
return {
'id': self.id,
'name': self.name,
'surname': self.surname,
'email': self.email,
'description': self.description,
'repository_url': self.repository_url,
'technologies': technologies,
}
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def __repr__(self):
return f'''
class Project(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), nullable=False)
description = db.Column(db.String(500), nullable=True)
repository_url = db.Column(db.String(500), nullable=False)
author_id = db.Column(db.Integer, db.ForeignKey('author.id'))
technologies = db.relationship('Technology',
secondary='project_technology',
lazy=False,
backref=db.backref('projects', lazy=True))
def is_valid(self):
if len(self.technologies) == 0:
return False
for technology in self.technologies:
if technology is None:
return False
return (self.name != '' and self.description != ''
and self.repository_url != '' and self.author_id is not None)
def format(self):
technologies = [tech.format() for tech in self.technologies]
return {
'id': self.id,
'name': self.name,
'description': self.description,
'repository_url': self.repository_url,
'author_id': self.author_id,
'technologies': technologies,
}
def insert(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def __repr__(self):
return f'''
class IncomeType(db.Model):
__tablename__ = "income_types"
id = db.Column(SMALLINT(unsigned=True), primary_key=True)
# 收入科目名称
name = db.Column(db.String(50), nullable=False)
# 收入科目层级，主营业务收入层级为 0
level = db.Column(TINYINT(unsigned=True), nullable=False, default=0)
# 本科目的下一层级科目
sub_types = db.relationship(
'IncomeType',
secondary='income_type_relation',
primaryjoin=(income_type_relation.c.sup_type == id),
secondaryjoin=(income_type_relation.c.sub_type == id),
backref=db.backref('sup_type', lazy='dynamic'),
lazy='dynamic')
# 本科目下的收入
incomes = db.relationship('Income', backref='incomes', lazy='dynamic')
class Url(db.Model):
__table_args__ = ({
'mysql_character_set': 'utf8mb4',
'mysql_collate': 'utf8mb4_unicode_520_ci'
})
id = Column('id', Integer, primary_key=True)
url = Column('url', String(80), unique=True, nullable=False)
description = Column('description', String(80), nullable=False)
challenge_id = Column('challenge',
Integer,
ForeignKey('challenge.id'),
nullable=False)
challenge = db.relationship('Challenge',
backref=db.backref('url', lazy=True))
def jsonify(self):
return {
'id': self.id,
'url': self.url,
'description': self.description
}
class User(db.Model):
__table_args__ = ({
'mysql_character_set': 'utf8mb4',
'mysql_collate': 'utf8mb4_unicode_520_ci'
})
id = Column('id', Integer, primary_key=True)
public_id = Column('publicId', String(80), unique=True, nullable=False)
username = Column('username', String(100), unique=True, nullable=False)
email = Column('email', String(100), unique=True, nullable=False)
password = Column('passwd', String(255), nullable=False)
created = Column('created', DateTime, nullable=False)
last_login = Column('lastLogin', DateTime)
role_id = Column('role', Integer, ForeignKey('role.id'), nullable=False)
role = db.relationship('Role', backref=db.backref('users', lazy=True))
def __init__(self, *args, **kwargs):
kwargs['password'] = sha512(kwargs['password'].encode()).hexdigest()
super().__init__(*args,
**kwargs,
public_id=str(uuid4()),
created=datetime.utcnow())
def jsonify(self):
from ..solve import Solve
return {
'publicId':
self.public_id,
'username':
self.username,
'email':
self.email,
'created':
self.created.strftime("%d.%m.%Y %H:%M:%S"),
'lastLogin':
self.last_login.strftime("%d.%m.%Y %H:%M:%S")
if self.last_login else None,
'role':
self.role.jsonify(),
'solved': [
solve.jsonify()
for solve in Solve.query.filter_by(user=self).all()
],
'points':
int(self.get_points())
}
def get_points(self):
from ..solve import Solve
points = 0
for solve in Solve.query.filter_by(user=self).all():
# TODO create tests
# if solution_date is null
if solve.challenge.solution_date:
# challenge has been solved before publication of the solution
if solve.timestamp < solve.challenge.solution_date:
points += solve.challenge.points
else:
points += solve.challenge.points
return points
# return list(db.engine.execute(f"""
# SELECT SUM(challenge.points) AS points FROM solve
# JOIN user on user.id = solve.user
# JOIN challenge on challenge.id = solve.challenge
# WHERE user.id = {self.id};
# """))[0][0]
def verify_password(self, password):
return self.password == sha512(password.encode()).hexdigest()
class Challenge(db.Model):
__table_args__ = ({
'mysql_character_set': 'utf8mb4',
'mysql_collate': 'utf8mb4_unicode_520_ci'
})
id = Column('id', Integer, primary_key=True)
flag = Column('flag', String(80), unique=True, nullable=False)
points = Column('points', Integer, nullable=False)
name = Column('name', String(80), nullable=False)
description = Column('description', String(512), nullable=False)
yt_challenge_id = Column('ytChallengeId', String(20), nullable=True)
yt_solution_id = Column('ytSolutionId', String(20), nullable=True)
publication = Column('publication', DateTime, nullable=False)
created = Column('created', DateTime, nullable=False)
solution_date = Column('solutionDate', DateTime)
category_id = Column('category',
Integer,
ForeignKey('category.id'),
nullable=False)
category = db.relationship('Category',
backref=db.backref('challenges', lazy=True))
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs, created=datetime.utcnow())
def min_jsonify(self):
# Used for solved challenges
return {
'id': self.id,
'name': self.name,
'description': self.description,
'category': self.category.jsonify(),
'points': self.points
}
def jsonify(self):
from ..solve import Solve
from ..url import Url
from ..rating import Rating
return {
'id':
self.id,
'name':
self.name,
'description':
self.description,
'category':
self.category.jsonify(),
'points':
self.points,
'ytChallengeId':
self.yt_challenge_id,
'ytSolutionId':
self.yt_solution_id,
'urls': [
url.jsonify()
for url in Url.query.filter_by(challenge=self).all()
],
'solveCount':
len(Solve.query.filter_by(challenge=self).all()),
'ratings': {
'thumbUp':
len(
Rating.query.filter_by(challenge=self,
thumb_up=True).all()),
'thumbDown':
len(
Rating.query.filter_by(challenge=self,
thumb_up=False).all())
}
}
class Centro_de_ayuda(db.Model):
__tablename__ = 'centro_de_ayuda'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String)
telefono = db.Column(db.String)
email = db.Column(db.String)
sitio_web = db.Column(db.String)
hora_de_apertura = db.Column(db.Time)
hora_de_cierre = db.Column(db.Time)
direccion = db.Column(db.String)
protocolo_de_vista = db.Column(db.String)
coordenada_x = db.Column(db.Integer)
coordenada_y = db.Column(db.Integer)
publicado = db.Column(db.Boolean)
historico = db.Column(db.Integer)
tipos_de_centro = db.relationship('Tipo_de_centro', secondary=tipos_de_centro, backref=db.backref(
'centros_de_ayuda_de_este_tipo', lazy=True), lazy='subquery')
municipio_id = db.Column(db.Integer, db.ForeignKey('municipio.id'))
municipio = db.relationship('Municipio', back_populates="centros_en_este_municipio")
estado_id = db.Column(db.Integer, db.ForeignKey('estado_centro.id'))
estado = db.relationship('Estado_centro', back_populates="centros_en_este_estado")
def all():
return Centro_de_ayuda.query.filter_by(historico=0).all()
def borrar(id):
centro = Centro_de_ayuda.query.filter_by(id=id).first()
centro.historico = 1
db.session.commit()
return True
def crear( nombre, direccion,telefono, hapertura, hcierre, email,sitio_web, corx, cory, lista_de_tipos, id_municipio, id_estado,protocolo='PDF', historico=0):
tipos = []
for tipo in lista_de_tipos:
tipos.append(Tipo_de_centro.query.filter_by(id=tipo).first())
# print("Entre al crear del modelo")
nuevo_centro = Centro_de_ayuda(nombre = nombre,
direccion = direccion,
telefono = telefono,
hora_de_apertura = hapertura,
hora_de_cierre=hcierre,
email=email,
sitio_web=sitio_web,
tipos_de_centro=tipos,
protocolo_de_vista=protocolo,
coordenada_y=cory,
coordenada_x=corx,
historico = historico,
municipio_id=id_municipio,
estado_id=id_estado,
publicado=False)
# print("Se creo en memoria el nuevo centro")
db.session.add(nuevo_centro)
db.session.commit()
return nuevo_centro
def set_protocolo(id,fn):
centro = Centro_de_ayuda.query.get(id)
centro.protocolo_de_vista = fn
db.session.commit()
return True
def editar(id, nombre, direccion,telefono, hapertura, hcierre, email,sitio_web, corx, cory, lista_de_tipos, id_municipio, id_estado,protocolo='PDF', historico=0):
centro = Centro_de_ayuda.query.get(id)
centro.nombre = nombre
centro.direccion = direccion
centro.telefono = telefono
centro.hora_de_apertura = hapertura
centro.hora_de_cierre = hcierre
centro.sitio_web = sitio_web
centro.email = email
centro.protocolo_de_vista = protocolo
centro.coordenada_x = corx
centro.coordenada_y = cory
centro.historico = historico
tipos = []
for tipo in lista_de_tipos:
tipos.append(Tipo_de_centro.query.filter_by(id=tipo).first())
centro.tipos_de_centro=tipos
db.session.commit()
return True
def existe_nombre(municipio_id,nombre):
return Centro_de_ayuda.query.filter_by(municipio_id=municipio_id,nombre=nombre).first()
def get_by_id(id):
return Centro_de_ayuda.query.get(id)
def aprobar(id):
centro = Centro_de_ayuda.query.get(id)
centro.estado = Estado_centro.query.filter_by(nombre='aceptado').first()
db.session.commit()
return True
def rechazar(id):
centro = Centro_de_ayuda.query.get(id)
centro.estado = Estado_centro.query.filter_by(nombre='rechazado').first()
db.session.commit()
return True
def publicar(id):
centro = Centro_de_ayuda.query.get(id)
centro.publicado = 1
db.session.commit()
return True
def despublicar(id):
centro = Centro_de_ayuda.query.get(id)
centro.publicado = 0
db.session.commit()
return True
def publicados():
return Centro_de_ayuda.query.filter_by(publicado=True).all()
def hola_mundo():
print("Hola mundo")
return True
class User(db.Model):
__tablename__ = 'usuario'
id = db.Column(db.Integer, primary_key=True)
usuario = db.Column(db.String)
clave = db.Column(db.String)
nombre = db.Column(db.String)
apellido = db.Column(db.String)
email = db.Column(db.String)
activo = db.Column(db.Integer)
fecha_actualizacion = db.Column(db.String)
fecha_creacion = db.Column(db.String)
historico = db.Column(db.Integer)
# Voy a crear una relacion entre tablas
# Lleva como argumento las clases involucradas
roles = db.relationship('Rol', secondary=roles, backref=db.backref(
'usuarios_con_el_rol', lazy=True), lazy='subquery')
def all():
return User.query.filter_by(historico=0).all()
def get_by_username(u):
return User.query.filter(User.usuario.contains(u)).first()
def get_by_id(id):
return User.query.get(id)
def get_by_email(email):
return User.query.filter(User.email.contains(email)).first()
def edit(i, us, cl, no, ap, em, ac, roles):
lista_roles = []
for rol in roles:
lista_roles.append(Rol.query.filter_by(id = rol).first())
datos = User.query.filter_by(id=i).first()
datos.usuario = us
datos.clave = cl
datos.nombre = no
datos.apellido = ap
datos.email = em
datos.activo = ac
datos.roles = lista_roles
db.session.commit()
return datos
# activar usuario
def activar_user(ide):
datos = User.query.filter_by(id=ide).first()
datos.activo = 1
db.session.commit()
return datos
# desactivar usuario
def desactivar_user(ide):
datos = User.query.filter_by(id=ide).first()
datos.activo = 0
db.session.commit()
return datos
# https://flask-sqlalchemy.palletsprojects.com/en/2.x/queries/
def create(us, cl, no, ap, em):
today = datetime.now()
nuevo_usuario = User(usuario=us, clave=cl, nombre=no, apellido=ap,
email=em, activo=True, fecha_actualizacion=today, fecha_creacion=today, historico=0)
db.session.add(nuevo_usuario)
db.session.commit()
return True
def delete(idx):
user = User.query.filter_by(id=idx).first()
user.historico = 1
db.session.commit()
return True
def delete_by_name(name):
user = User.query.filter_by(usuario=name).first()
db.session.delete(user)
db.session.commit()
return True
def get_by_email_and_pass(usuario, clave):
return User.query.filter_by(usuario=usuario, clave=clave).first()
######################## VALIDACIONES ########################
def existe_usuario(username):
return User.query.filter_by(usuario=username).first()
def existe_email(email):
return User.query.filter_by(email=email).first()
######################## ROLES Y PERMISOS ########################
def get_roles(id_usuario):
return Usuario_tiene_rol.query.filter_by(usuario_id=id_usuario)
def agregar_rol(usuario, rol):
rol.usuarios.append(usuario)
db.session.commit()
return True
def quitar_rol(usuario, rol):
rol.usuarios.remove(usuario)
db.session.commit()
return True
def tiene_rol(usuario, nombre_rol):
res = False
for rol in usuario.roles:
if rol.nombre == nombre_rol:
res = True
return res
def tiene_permiso(usuario, nombre_permiso):
res = False
for rol in usuario.roles:
for permiso in rol.permisos:
if permiso.nombre == nombre_permiso:
res = True
return res
###################################################################
