class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('blog_user.id', ondelete='CASCADE'),
nullable=False)
title = db.Column(db.String(256), nullable=False)
title_slug = db.Column(db.String(256), unique=True, nullable=False)
content = db.Column(db.Text)
def __repr__(self):
return f'<Post {self.title}>'
def save(self):
if not self.id:
db.session.add(self)
if not self.title_slug:
self.title_slug = slugify(self.title)
saved = False
count = 0
while not saved:
try:
db.session.commit()
saved = True
except IntegrityError:
count += 1
self.title_slug = f'{self.title_slug}-{count}'
def public_url(self):
return url_for('show_post', slug=self.title_slug)
@staticmethod
def get_by_slug(slug):
return Post.query.filter_by(title_slug=slug).first()
@staticmethod
def get_all():
return Post.query.all()
class Usuario(UserMixin, db.Model):
def __init__(self, nombre, apellido, email, psw):
self.nombre = nombre
self.apellido = apellido
self.email = email
self.password_hash = generate_password_hash(psw)
usuarioId = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(40), nullable=False)
apellido = db.Column(db.String(30), nullable=False)
email = db.Column(db.String(60), nullable=False)
password_hash = db.Column(db.String(128), nullable=False)
admin = db.Column(db.Boolean, nullable=False, default=False)
eventos = db.relationship("Evento",
back_populates="usuario",
cascade="all, delete-orphan")
comentarios = db.relationship("Comentario",
back_populates="usuario",
cascade="all, delete-orphan")
@property
def password(self):
raise AttributeError('La password no puede leerse')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def get_id(self):
return self.usuarioId
def verificar_pass(self, password):
return check_password_hash(self.password_hash, password)
def __repr__(self):
return str(self.nombre) + ' ' + str(self.apellido)
def is_admin(self): # Comprueba si el usuario es administrador
aux = False
if self.admin == 1:
aux = True
return aux
def is_owner(
self, event_or_coment
): # Comprueba si el usuario es dueño, puede usarse con comentarios o eventos.
aux = False
if self.usuarioId == event_or_coment.usuarioId:
aux = True
return aux
class User(db.Model, UserMixin):
__tablename__ = 'blog_user'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
email = db.Column(db.String(256), unique=True, nullable=False)
password = db.Column(db.String(128), nullable=False)
is_admin = db.Column(db.Boolean, default=False)
def __repr__(self):
return f'<User {self.email}>'
def set_password(self, password):
"""
To avoid a security problem, instead of saving user passwords, we will save a password HASH using the
werkzeug.security library.
"""
self.password = generate_password_hash(password)
def check_password(self, password):
"""
The check_password method VERIFIES if the hash of the password parameter matches that of the user.
"""
return check_password_hash(self.password, password)
def save(self):
if not self.id:
db.session.add(self)
db.session.commit()
@staticmethod
def get_by_id(id):
"""Query operations on gets"""
return User.query.get(id)
@staticmethod
def get_by_email(email):
return User.query.filter_by(email=email).first()
class Articulos(db.Model):
__tablename__ = 'articulos'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(100), nullable=False)
precio = db.Column(db.Integer, default=0, nullable=False)
descripcion = db.Column(db.String(225), nullable=False)
image = db.Column(db.String(225))
wppurl = db.Column(db.String(2000), nullable=False)
CategoriaId = db.Column(db.Integer, ForeignKey('categorias.id'))
categoria = relationship("Categorias", backref="Articulos")
def __repr__(self):
return (u'<{self.__class__.__name__}: {self.id}>'.format(self=self))
class UserModel(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
phone = db.Column(db.String(20), nullable=True)
gender = db.Column(db.Enum(*Gender.get_enum_labels()), default=Gender.NONE.value) # gender
birthday = db.Column(db.Date, nullable=True)
email = db.Column(db.String(255), nullable=False, default="")
menu_list = db.relationship('MenuModel', back_populates='owner', lazy=True)
order_list = db.relationship('OrderModel', back_populates='owner', lazy=True)
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def get_by_id(cls, user_id: int):
return cls.query.get(user_id)
@classmethod
def return_all(cls):
def to_json(x):
return {
'username': x.username,
'email': x.email
}
return {'users': list(map(lambda x: to_json(x), UserModel.query.all()))}
@classmethod
def delete_all(cls):
try:
num_rows_deleted = db.session.query(cls).delete()
db.session.commit()
return {'message': '{} row(s) deleted'.format(num_rows_deleted)}
except:
return {'message': 'Something went wrong'}
@staticmethod
def generate_hash(password):
return sha256.hash(password)
@staticmethod
def verify_hash(password, hash_value):
return sha256.verify(password, hash_value)
class AoModel(db.Model, JsonModel):
__tablename__ = 'ao'
id = db.Column(db.BigInteger, primary_key=True)
name = db.Column(db.String(120))
type = db.Column(db.String(120))
avg_sq = db.Column(db.Float)
avg_coeff = db.Column(db.Integer)
# coordinates = db.Column(MutableList.as_mutable(ARRAY(db.Float)), server_default="{}")
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def delete(cls, id):
deleted = cls.query.filter_by(id=id).delete()
db.session.commit()
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def return_all(cls):
def to_json(x):
return {
'id': x.id,
'name': x.name,
'type': x.type,
'avg_sq': x.avg_sq,
'avg_coeff': x.avg_coeff,
# 'coordinates': x.coordinates
}
return {'ao': list(map(lambda x: to_json(x), AoModel.query.all()))}
class User(db.Model, UserMixin):
__tablename__ = 'tracking_user'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
email = db.Column(db.String(256), unique=True, nullable=False)
password = db.Column(db.String(128), nullable=False)
is_admin = db.Column(db.Boolean, default=False)
devices = db.relationship('Device', backref='devices', lazy=True)
def __repr__(self):
return f'<User {self.email}>'
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
def save(self):
if not self.id:
db.session.add(self)
db.session.commit()
@staticmethod
def get_by_id(id):
return User.query.get(id)
@staticmethod
def get_by_email(email):
return User.query.filter_by(email=email).first()
class SurveyModel(db.Model):
__tablename__ = 'survey'
id = db.Column(db.Integer, primary_key=True)
sector = db.Column(db.String(50), nullable=False)
subsector = db.Column(db.String(50), nullable=True)
questions = db.Column(db.String(100), nullable=True)
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def find_by_sector(cls, sector, subsector):
return cls.query.filter_by(sector=sector).filter_by(
subsector=subsector).first()
@classmethod
def find_all(cls):
return cls.query.all()
class User(db.Model, UserMixin):
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.String(50), unique=True, nullable=False)
password_hash = db.Column(db.String(80), nullable=False)
email_address = db.Column(db.String(50), unique=True, nullable=False)
def __str__(self):
return f"{self.username} {self.email_address}"
def get_user_id(self):
return self.id
@property
def password(self):
return self.password
@password.setter
def password(self, plain_text_password):
self.password_hash = bcrypt.generate_password_hash(plain_text_password).decode(
"utf-8"
)
def check_password(self, attempted_password):
return bcrypt.check_password_hash(self.password_hash, attempted_password)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def return_all(cls):
def to_json(x):
return {'username': x.username}
return list(map(lambda x: to_json(x), User.query.all()))
@classmethod
def delete_all(cls):
try:
num_rows_deleted = db.session.query(cls).delete()
db.session.commit()
return {'message': '{} row(s) deleted'.format(num_rows_deleted)}
except:
return {'message': 'Something went wrong'}
@staticmethod
def generate_hash(password):
return sha256.hash(password)
@staticmethod
def verify_hash(password, hash):
return sha256.verify(password, hash)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True, index=True)
name = db.Column(db.String(64), nullable=False)
email = db.Column(db.String(30), nullable=False)
password = db.Column(db.String(64), nullable=False)
role_id = db.Column(db.Integer, db.ForeignKey('role.id'))
def __repr__(self):
return '<User %r>' % self.username
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column('user_ID', db.Integer, primary_key=True)
name = db.Column('name', db.Unicode, unique=True)
email = db.Column('email', db.Unicode)
username = db.Column('username', db.Unicode)
password = db.Column('password', db.Unicode)
date = db.Column('created_date', db.TIMESTAMP)
class User(db.Model):
email = db.Column(db.String(60), primary_key=True)
code = db.Column(db.String(6))
status = db.Column(db.Integer, default=0) # 0.注册状态 1.注册成功状态 2.管理员审核通过 3.黑名单用户
created_time = db.Column(db.DateTime, default=datetime.now)
updated_time = db.Column(db.DateTime, default=datetime.now, onupdate=datetime.now)
password = db.Column(db.String(100))
def __repr__(self):
return '<User: %s>' % self.email
class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
date_created = db.Column(db.DateTime, default=datetime.datetime.utcnow)
created_by = db.Column(db.Integer, nullable=True)
date_modified = db.Column(db.DateTime, nullable=True)
modified_by = db.Column(db.Integer, nullable=True)
status = db.Column(db.Integer, default=1, nullable=False)
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def return_all(cls):
def to_json(x):
return {'username': x.username, 'password': x.password}
return {
'users': list(map(lambda x: to_json(x), UserModel.query.all()))
}
@classmethod
def delete_all(cls):
try:
num_rows_deleted = db.session.query(cls).delete()
db.session.commit()
return {'message': '{} row(s) deleted'.format(num_rows_deleted)}
except:
return {'message': 'Something went wrong'}
@staticmethod
def generate_hash(password):
return sha256.hash(password)
@staticmethod
def verify_hash(password, hash):
return sha256.verify(password, hash)
class citizen_report(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
age = db.Column(db.String(100))
sex = db.Column(db.String(100))
phone = db.Column(db.String(100))
state = db.Column(db.String(100))
city = db.Column(db.String(100))
symptoms = db.Column(db.String(255))
def __init__(self, name, age, sex, phone, state, city, symptoms):
self.name = name
self.age = age
self.sex = sex
self.phone = phone
self.state = state
self.city = city
self.symptoms = symptoms
class UniversityInfo(db.Model): # Universite Bilgileri
id = db.Column(db.Integer, primary_key=True)
university_student_no = db.Column(db.Integer,
nullable=False) # Üniversite Öğrenci No
faculty = db.Column(db.String(25), nullable=False) # Fakülte / MYO
department = db.Column(db.String(120), nullable=False) # Bölüm / Program
teaching_style = db.Column(db.String(120),
nullable=False) # Öğretim Şekli --
student_score = db.Column(db.Integer, nullable=False) # Öss Puanı --
completed_yok = db.Column(db.String(120),
nullable=False) # Tamamlanan Yök --
preferences = db.relationship('UniversityPreferences',
backref=db.backref('university_info',
lazy=True))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return "<StudentUniversityInfo {0!r}>".format(self.id)
class Employee(db.Model):
__tablename__ = 'employee'
id = db.Column(db.Integer,primary_key=True)
name = db.Column(db.String)
gender = db.Column(db.String)
job = db.Column(db.String)
salary = db.Column(db.Float)
birthdate = db.Column(db.Date)
idcard = db.Column(db.String)
address = db.Column(db.String)
departmentid = db.Column(db.Integer,db.ForeignKey('department.id'))
department = db.relationship('Department',backref=db.backref('employees',lazy='dynamic'))
def __init__(self,name=None,gender=None,job=None,salary=0.0,birthdate=None,idcard=None,address=None):
self.name = name
self.gender = gender
self.job = job
self.salary = salary
self.birthdate = birthdate
self.idcard = idcard
self.address = address
class Todo(db.Model):
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.String(255), nullable=False)
date_created = db.Column(db.DateTime, default=datetime.utcnow)
date_todo = db.Column(db.DateTime, nullable=False)
date_completed = db.Column(db.DateTime, nullable=False)
users_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
def __repr__(self):
return '<Task %r %r %r %r %r %r >' % (
self.id, self.content, self.date_created, self.date_todo,
self.date_completed, self.users_id)
class Passenger(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String)
editURL = db.Column(db.String)
validated = db.Column(db.Boolean)
oLat = db.Column(db.Numeric)
oLon = db.Column(db.Numeric)
dLat = db.Column(db.Numeric)
dLon = db.Column(db.Numeric)
date = db.Column(db.String)
picks = db.relationship('Driver',
secondary='passengerPicks',
backref=db.backref('pickedBy', lazy='dynamic'))
def __init__(self, email, oLat, oLon, dLat, dLon, date, url):
self.email = email
self.validated = False
self.oLat = oLat
self.oLon = oLon
self.dLat = dLat
self.dLon = dLon
self.date = date
self.editURL = url
def __repr__(self):
return '<User %r>' % self.email
def pick(self, driver):
self.picks.append(driver)
return self
def unpick(self, driver):
self.picks.remove(driver)
return self
def validate(self):
self.validated = True
return self
class User(db.Model): # ORM içindeki yapıdan todo tablomuzu türetiyoruz
id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
nullable=False)
username = db.Column(db.String(20), nullable=False)
email = db.Column(db.String(20), nullable=False)
password = db.Column(db.Text, nullable=False)
create_date = db.Column(db.DateTime,
default=datetime.utcnow,
nullable=False)
verified = db.Column(db.Integer, default=0)
class BranchModel(db.Model):
"""
Contains branch information of the Bank.
A Bank has many branches : ManyToOne Rel to Bank
"""
__tablename__ = 'branch'
id = db.Column(db.Integer, primary_key=True)
ifsc = db.Column(db.String(20))
branch_name = db.Column(db.String(120))
address = db.Column(db.String(120))
city = db.Column(db.String(120))
district = db.Column(db.String(120))
state = db.Column(db.String(120))
def __init__(self, ifsc, branch_name, address, city, district, state):
self.ifsc = ifsc
self.branch_name = branch_name
self.address = address
self.city = city
self.district = district
self.state = state
def json(self):
return {
'BranchId': self.id,
'ifsc': self.ifsc,
'branch_name': self.branch_name,
'address': self.address,
'city': self.city,
'district': self.district,
'state': self.district
}
# @classmethod
# def find_by_ifsc(cls):
# return cls.query.first() # simple TOP 1 select
@classmethod
def find_by_ifsc(cls, ifsc):
return cls.query.filter_by(ifsc=ifsc).first() # simple TOP 1 select
def save_to_db(self): # Upserting data
db.session.add(self)
db.session.commit() # Balla
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class patient_detail(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
age = db.Column(db.String(100))
sex = db.Column(db.String(100))
state = db.Column(db.String(100))
city = db.Column(db.String(100))
status = db.Column(db.String(100))
def __init__(self, name, age, sex, state, city, status):
self.name = name
self.age = age
self.sex = sex
self.state = state
self.city = city
self.status = status
class HighschoolInfo(db.Model): # Mezun Olunan Lise Bilgileri
id = db.Column(db.Integer, primary_key=True)
school_name = db.Column(db.String(120),
nullable=False) # Mezun Olunan Lise --
school_department = db.Column(db.String(25),
nullable=False) # Mezun Olunan Bölüm --
diploma_success_note = db.Column(db.String(11),
nullable=False) # Diploma Başarı Notu --
diploma_course_branch = db.Column(
db.String(11), nullable=False) # Diploma Kolu / Branşı --
foreign_language = db.Column(db.String(11),
nullable=False) # Yabanci Dil --
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return "<StudentHighschoolInfo {0!r}>".format(self.id)
class User(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
nickname = db.Column(db.String(255))
account = db.Column(db.String(255))
password = db.Column(db.String(255))
role = db.Column(db.Integer, default=1)
status = db.Column(db.Integer, default=1)
createtime = db.Column(db.DateTime, default=datetime.datetime.now)
def __init__(self, account, nickname, password, role, status):
self.account = account
self.nickname = nickname
self.password = md5(password)
self.role = role
self.status = status
class Previsao(db.Model):
cidade = db.Column(db.Integer,
db.ForeignKey('cidade.id'),
primary_key=True)
data = db.Column(db.Date, nullable=False, primary_key=True)
probabilidade = db.Column(db.Float, nullable=False)
precipitacao = db.Column(db.Float, nullable=False)
min = db.Column(db.Float, nullable=False)
max = db.Column(db.Float, nullable=False)
__table_args__ = (db.UniqueConstraint('data',
'cidade',
name="uma_data_por_cidade"), )
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(60))
body = db.Column(db.Text)
timestamp = db.Column(db.DateTime, default=datetime.utcnow, index=True)
can_comment = db.Column(db.Boolean, default=True)
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category', back_populates='posts')
comments = db.relationship('Comment',
back_populates='post',
cascade='all, delete-orphan')
class Link(db.Model):
"""Represents an interesting link."""
def __str__(self):
"""Simple log method."""
return str(id)
__tablename__ = 'links'
id = db.Column(db.Integer, primary_key=True)
order = db.Column(db.Integer, unique=False)
url = db.Column(db.Text(), unique=False)
image = db.Column(db.Text(), unique=False)
title = db.Column(db.Text(), unique=False, default=u'Titre')
description = db.Column(db.Text(), unique=False, default=u'Description')
class UserModelStudent(UserDataModelFactory, db.Model):
__tablename__ = 'students'
id = db.Column(db.Integer, primary_key=True)
uuid = db.Column(db.String(120), unique=True, nullable=False)
username = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
usertype = db.Column(db.String(120), nullable=False)
is_admin = db.Column(db.Boolean, unique=False, default=False)
def set_data_fields(self, data):
self.uuid = data.uuid
self.username = data.username
self.password = data.password
self.is_admin = data.is_admin
self.usertype = data.usertype
def save_to_db(self):
db.session.add(self)
db.session.commit()
print(self.id)
@classmethod
def find_by_uuid(cls, uuid):
return cls.query.filter_by(uuid=uuid).first()
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def return_all(cls):
def to_json(json_vals):
return {
'username': json_vals.username,
'password': json_vals.password
}
return {
'users':
list(map(lambda x: to_json(x), UserModelStudent.query.all()))
}
@classmethod
def delete_all(cls):
try:
num_rows_deleted = db.session.query(cls).delete()
db.session.commit()
return {'message': '{} row(s) deleted'.format(num_rows_deleted)}
except:
return {'message': 'Something went wrong'}
class Comments(db.Model):
id = db.Column(db.Integer, primary_key=True)
issue = db.Column(db.String(255))
author = db.Column(db.String(255))
avatr = db.Column(db.String(255))
text = db.Column(db.String(255))
timestamp = db.Column(db.String(255))
def __init__(self, issue, author, avatr, text, timestamp):
self.issue = issue
self.author = author
self.avatr = avatr
self.text = text
self.timestamp = timestamp
class Issues(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255))
status = db.Column(db.Integer)
author = db.Column(db.String(255))
labels = db.Column(db.String(255))
timestamp = db.Column(db.String(255))
def __init__(self, title, status, author, labels, timestamp):
self.title = title
self.status = status
self.author = author
self.labels = labels
self.timestamp = timestamp
