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 ###################################################################