class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), nullable=False)
password = db.Column(db.String(128), nullable=False)
email = db.Column(db.String(128), nullable=False)
club = db.Column(db.String(128), nullable=True)
admin = db.Column(db.Boolean(), default=False, nullable=False)
super_admin = db.Column(db.Boolean(), default=False, nullable=False)
def __init__(self, username, password, email, club, admin, super_admin):
self.username = username
self.password = password
self.email = email
self.club = club
self.admin = admin
self.super_admin = super_admin
def to_json(self):
return {
'id': self.id,
'username': self.username,
'password': self.password,
'email': self.email,
'club': self.club,
'admin': self.admin,
'superadmin': self.super_admin
}
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password_hash = db.Column(db.String(128))
active = db.Column(db.Boolean(), default=True, nullable=False)
created_date = db.Column(db.DateTime, default=func.now(), nullable=False)
is_admin = db.Column(db.Boolean(), default=False, nullable=False)
projects = db.relationship('Project', backref='user', lazy=True)
def to_json(self):
return {
'id': self.id,
'username': self.username,
'email': self.email,
'active': self.active
}
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
created_date = db.Column(db.DateTime, default=func.now(), nullable=False)
admin = db.Column(db.Boolean(), default=False, nullable=False)
def __init__(self, username, email, password):
self.username = username
self.email = email
log_rounds = current_app.config.get('BCRYPT_LOG_ROUNDS')
self.password = bcrypt.generate_password_hash(password,
log_rounds).decode()
def __repr__(self):
return '<User %r>' % self.username
def to_json(self):
return {
'id': self.id,
'username': self.username,
'email': self.email,
'active': self.active,
'admin': self.admin
}
def encode_auth_token(self, user_id):
"""Generates the auth token"""
try:
days = current_app.config.get('TOKEN_EXPIRATION_DAYS')
seconds = current_app.config.get('TOKEN_EXPIRATION_SECONDS')
payload = {
'exp':
datetime.datetime.utcnow() +
datetime.timedelta(days=days, seconds=seconds),
'iat':
datetime.datetime.utcnow(),
'sub':
user_id
}
return jwt.encode(payload,
current_app.config.get('SECRET_KEY'),
algorithm='HS256')
except Exception as e:
return e
@staticmethod
def decode_auth_token(token):
try:
payload = jwt.decode(token, current_app.config.get('SECRET_KEY'))
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
class SimpleUser(db.Model):
__tablename__ = "simple_users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(128), index=True, unique=True, nullable=False)
# ip = db.Column(db.String(15), nullable=False)
subscribed = db.Column(db.Boolean(), default=True, nullable=False)
registered = db.Column(db.Boolean(), default=False, nullable=False)
online = db.Column(db.Boolean(), default=True, nullable=False)
lastlogin = db.Column(db.DateTime,
index=True,
default=datetime.utcnow,
nullable=False)
lastlogout = db.Column(db.DateTime, index=True, nullable=True)
created_at = db.Column(db.DateTime,
index=True,
default=datetime.utcnow,
nullable=False)
def __repr__(self):
return "<SimpleUser {}>".format(self.email)
def to_dict(self):
return {
"id": self.id,
"email": self.email,
"subscribed": self.subscribed,
"registered": self.registered,
"online": self.online,
"lastlogin": str(self.lastlogin),
"lastlogout": str(self.lastlogout),
"created_at": str(self.created_at),
}
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
admin = db.Column(db.Boolean(), default=False, nullable=False)
def __init__(self, username, email, password):
self.username = username
self.email = email
self.password = bcrypt.generate_password_hash(
password, current_app.config.get('BCRYPT_LOG_ROUNDS')).decode()
def to_json(self):
return {
'id': self.id,
'username': self.username,
'email': self.email,
'active': self.active,
'admin': self.admin
}
def encode_auth_token(self, user_id):
""" Generates auth token """
# given user_id encodes and returns a token
try:
payload = {
'exp':
datetime.datetime.utcnow() + datetime.timedelta(
days=current_app.config.get('TOKEN_EXPIRATION_DAYS'),
seconds=current_app.config.get(
'TOKEN_EXPIRATION_SECONDS') # expiration date
),
'iat':
datetime.datetime.utcnow(), # issued at
'sub':
user_id # subject of token - user whom identifies
}
return jwt.encode(payload,
current_app.config.get('SECRET_KEY'),
algorithm='HS256')
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
""" Decodes the auth_token - :param auth_token: - return: integer|string"""
try:
payload = jwt.decode(auth_token,
current_app.config.get('SECRET_KEY'))
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again'
except jwt.InvalidTokenError:
return 'Invalid token. Please try again.'
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
admin = db.Column(db.Boolean(), default=False, nullable=False)
created_at = db.Column(db.DateTime, nullable=False)
def __init__(
self, username, email, password,
created_at = datetime.datetime.utcnow()):
self.username = username
self.email = email
self.password = bcrypt.generate_password_hash(
password, current_app.config.get('BCRYPT_LOG_ROUNDS')
).decode()
self.created_at = created_at
def encode_auth_token(self, user_id):
"""Generates the auth token"""
try:
payload = {
'exp': datetime.datetime.utcnow() + datetime.timedelta(
days=current_app.config.get('TOKEN_EXPIRATION_DAYS'),
seconds=current_app.config.get('TOKEN_EXPIRATION_SECONDS')
),
'iat': datetime.datetime.utcnow(),
'sub': user_id
}
return jwt.encode(
payload,
current_app.config.get('SECRET_KEY'),
algorithm='HS256'
)
except Exception as e:
raise e
@staticmethod
def decode_auth_token(auth_token):
"""Decodes the auth token
:params auth_token:
:return: integer|string
"""
try:
payload = jwt.decode(auth_token, current_app.config.get('SECRET_KEY'))
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
class Password(db.Model):
__tablename__ = 'passwords'
user_id = db.Column(db.Integer, primary_key=True)
password_hash = db.Column(db.String(128), nullable=False)
salt = db.Column(db.String(128), nullable=False)
auth_allowed = db.Column(db.Boolean(), default=True, nullable=False)
is_admin = db.Column(db.Boolean(), default=False, nullable=False)
def __init__(self, user_id, password, is_admin=False):
self.user_id = user_id
self.set_password(password)
self.is_admin = is_admin
def set_password(self, password):
random_val = str(SystemRandom().getrandbits(32*8)) # generate a salt with 32 random bytes
# random_str = ""
# # Python chr(i) supports input from 0 to 1114111, so at least 6 digits/char allowed
# for i in range(0, len(random_val), 6):
# char_nr = int("".join(random_val[i + k] for k in range(6) if i + k < len(random_val)))
# char = chr(char_nr + 32)
# if unicodedata.category(char) not in 'cC': # not a control character
# random_str += char
# self.salt = random_str
self.salt = random_val
self.password_hash = pwd_context.hash(self.salt + password)
def verify_password(self, password):
return pwd_context.verify(self.salt + password, self.password_hash)
def generate_auth_token(self, expiration=6000):
s = Serializer(get_app().config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'user_id': self.user_id})
@staticmethod
def verify_auth_token(token):
s = Serializer(get_app().config['SECRET_KEY'])
try:
data = s.loads(token)
except SignatureExpired:
return None # Expired valid token
except BadSignature:
return None # Invalid token
user_id = Password.query.get(data['user_id'])
return user_id
def to_json(self):
return {
'user_id': self.user_id,
'password_hash': self.password_hash,
'salt': self.salt,
'auth_allowed': self.auth_allowed
}
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
admin = db.Column(db.Boolean(), default=False, nullable=False)
created_date = db.Column(
db.DateTime,
default=datetime.utcnow,
nullable=False
)
def __init__(self, username, email, password):
self.username = username
self.email = email
self.password = bcrypt.generate_password_hash(
password,
current_app.config.get('BCRYPT_LOG_ROUNDS')
).decode()
@classmethod
def get_all(cls) -> List["User"]:
return cls.query.all()
@classmethod
def find_by_id(cls, _id: int) -> "User":
return cls.query.filter_by(id=_id).first()
@classmethod
def find_by_username(cls, username: str) -> "User":
return cls.query.filter_by(username=username).first()
@classmethod
def find_existing_user(cls, username: str, email: str) -> "User":
return cls.query.filter(
(cls.username == username) | (cls.email == email)
).first()
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Smartphone(db.Model):
__tablesmartphone__ = 'smartphones'
idSmartphone = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), nullable=False)
brand = db.Column(db.String(128), nullable=False)
price = db.Column(db.String(4), nullable=False)
creation_date = db.Column(db.DateTime, default=func.now(), nullable=False)
modification_date = db.Column(db.DateTime,
default=func.now(),
nullable=True)
status = db.Column(db.Boolean(), default=True, nullable=False)
def to_json(self):
return {
'idSmartphone': self.idSmartphone,
'name': self.name,
'brand': self.brand,
'price': self.price
}
def __init__(self, name, brand, price):
self.name = name
self.brand = brand
self.price = price
class Smartphone(db.Model):
__tablename__ = 'smartphones'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), nullable=False)
brand = db.Column(db.String(128), nullable=False)
price = db.Column(db.Float(4), nullable=False)
color = db.Column(db.String(128), nullable=False)
quantity = db.Column(db.Float(2), nullable=False)
propietario = db.Column(db.Integer, db.ForeignKey('personas.id'))
creation_date = db.Column(db.DateTime, default=func.now(), nullable=False)
modification_date = db.Column(db.DateTime,
default=func.now(),
nullable=True)
active = db.Column(db.Boolean(), default=True, nullable=False)
def __init__(self, **kwargs):
super(Smartphone, self).__init__(**kwargs)
# do custom initialization here
def to_json(self):
return {
'id': self.id,
'name': self.name,
'brand': self.brand,
'price': self.price,
'color': self.color,
'propietario': self.propietario,
'quantity': self.quantity,
'active': self.active
}
class Persona(db.Model):
__tablename__ = 'personas'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), nullable=False)
lastname = db.Column(db.String(128), nullable=False)
age = db.Column(db.Float(2), nullable=False)
gender = db.Column(db.String(1), nullable=False)
smartphones = db.relationship('Smartphone')
creation_date = db.Column(db.DateTime, default=func.now(), nullable=False)
modification_date = db.Column(db.DateTime,
default=func.now(),
nullable=True)
active = db.Column(db.Boolean(), default=True, nullable=False)
def __init__(self, name, lastname, age, gender):
self.name = name
self.lastname = lastname
self.age = age
self.gender = gender
def to_json(self):
return {
'id': self.id,
'name': self.name,
'lastname': self.lastname,
'age': self.age,
'gender': self.gender,
'active': self.active
}
class User(UserMixin, db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True, nullable=False)
active = db.Column(db.Boolean(), nullable=False, default=True)
apikey = db.Column(db.String(36),
index=True,
unique=True,
nullable=False,
default=generate_apikey)
email = db.Column(db.String(255), nullable=False, unique=True)
first_name = db.Column(db.String(50), nullable=False)
last_name = db.Column(db.String(50), nullable=False)
password = db.Column(db.String(130), nullable=False)
roles = db.relationship('Role',
secondary=roles_users_association,
backref=db.backref('users', lazy='dynamic'))
username = db.Column(db.String(255), nullable=False, unique=True)
def __str__(self):
return str(self.username)
def to_dict(self):
return {
'id': self.id,
'active': self.active,
'email': self.email,
'first_name': self.first_name,
'last_name': self.last_name,
'roles': sorted([r.name for r in self.roles]),
'username': self.username
}
class AbstractModelWithAttributes(AbstractModel, object):
id = db.Column(db.String(40), default=_generate_uuid, primary_key=True)
creation_date = db.Column(DateTime(timezone=True),
default=func.now(),
nullable=False)
modification_date = db.Column(DateTime(timezone=True), nullable=True)
remove_date = db.Column(DateTime(timezone=True),
default=datetime.min,
nullable=False)
enabled = db.Column(db.Boolean(), default=True, nullable=False)
@staticmethod
def filter(cls, filters):
query = super().filter(cls, filters)
if 'id' in filters:
query = query.filter_by(id=filters['id'])
if 'enabled' in filters:
query = query.filter_by(enabled=filters['enabled'])
return query
def update(self):
self.modification_date = func.now()
self.insert()
def soft_delete(self):
self.enabled = False
self.remove_date = func.now()
self.insert()
def restore(self):
self.enabled = True
self.remove_date = datetime.min
self.insert()
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), nullable=False)
password = db.Column(db.String(128), nullable=False)
email = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
def encode_auth_token(self, user_id):
"""Generate the auth token"""
try:
payload = {
"exp": datetime.datetime.utcnow() + datetime.timedelta(
days=current_app.config.get('TOKEN_EXPIRATION_DAYS'),
seconds=current_app.config.get('TOKEN_EXPIRATION_SECONDS')
),
"iat": datetime.datetime.utcnow(),
"sub": user_id
}
return jwt.encode(
payload,
current_app.config.get("SECRET_KEY"),
algorithms="HS256"
)
except as e:
return e
class Usuario(db.Model):
__tablename__ = 'usuario'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
usuario = db.Column(db.String(128), nullable=False)
clave = db.Column(db.String(128), nullable=False)
estado = db.Column(db.Boolean(), default=True, nullable=False)
tipocuenta = db.Column(db.Integer, default=1, nullable=False)
idparticipante = db.Column(db.Integer, nullable=False)
def to_json(self):
return {
'id': self.id,
'usuario': self.usuario,
'clave': self.clave,
'estado': self.estado,
'tipocuenta': self.tipocuenta,
'idparticipante': self.idparticipante
}
def __init__(self, usuario, clave, idparticipante):
self.usuario = usuario
self.clave = clave
self.idparticipante = idparticipante
class Participante(db.Model):
__tablename__ = 'participante'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
nombre = db.Column(db.String(100), nullable=False)
apellido = db.Column(db.String(100), nullable=False)
email = db.Column(db.String(128), nullable=True)
celular = db.Column(db.String(9), nullable=True)
nivel = db.Column(db.Integer, default=0, nullable=True)
fechanacimiento = db.Column(db.String(20), nullable=True)
estado = db.Column(db.Boolean(), default=True, nullable=True)
sexo = db.Column(db.Integer, default=0, nullable=True)
def to_json(self):
return {
'id': self.id,
'nombre': self.nombre,
'apellido': self.apellido,
'email': self.email,
'celular': self.celular,
'nivel': self.nivel,
'fechanacimiento': self.fechanacimiento,
'estado': self.estado,
'sexo': self.sexo,
}
def __init__(self, nombre, apellido, email, celular, fechanacimiento):
self.nombre = nombre
self.apellido = apellido
self.email = email
self.celular = celular
self.fechanacimiento = fechanacimiento
class DairyCattle(Bovine):
bovine_id = db.Column(db.Integer, db.ForeignKey('bovine.bovine_id'), primary_key=True)
is_pregnant = db.Column(db.Boolean(), nullable=True)
reproduction_managements = db.relationship('ReproductionManagementModel', backref='farm', lazy=True)
__mapper_args__ = {
'polymorphic_identity': 'dairy_cattle'
}
def init(self, farm_id, name, date_of_birth, breed, actual_weight,
is_beef_cattle, is_pregnant, batch_of_beef):
self.farm_id = farm_id
self.name = name
self.breed = breed
self.actual_weight = actual_weight
self.date_of_birth = date_of_birth
self.is_beef_cattle = is_beef_cattle
self.is_pregnant = is_pregnant,
self.batch_of_beef = batch_of_beef
def to_json(self):
return {
'bovine_id': self.bovine_id,
'farm_id': self.farm_id,
'name': self.name,
'date_of_birth': str(self.date_of_birth),
'breed': self.breed,
'actual_weight': float(self.actual_weight),
'is_beef_cattle': self.is_beef_cattle,
'is_pregnant': self.is_pregnant,
'batch_of_beef': self.batch_of_beef
}
class Cliente(db.Model): # nuevo
__tablename__ = 'clientes'
idclientes = db.Column(db.Integer, primary_key=True, autoincrement=True)
nombres = db.Column(db.String(128), nullable=False)
apellidos = db.Column(db.String(128), nullable=False)
telefono = db.Column(db.Integer, nullable=False)
email = db.Column(db.String(128), nullable=False)
estado = db.Column(db.Boolean(), default=True, nullable=False)
# facturas = db.relationship('Factura', backref='cliente', lazy='dynamic', cascade='all, delete-orphan')
def to_json(self):
return {
'idclientes': self.idclientes,
'nombres': self.nombres,
'apellidos': self.apellidos,
'telefono': self.telefono,
'email': self.email,
'estado': self.estado
}
def __init__(self, nombres, apellidos, telefono, email):
self.nombres = nombres
self.apellidos = apellidos
self.telefono = telefono
self.email = email
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), nullable=False)
email = db.Column(db.String(128), nullable=False)
address = db.Column(db.String(128), nullable=False)
phone = db.Column(db.String(128), nullable=False)
age = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
def to_json(self):
return {
'id': self.id,
'username': self.username,
'email': self.email,
'address': self.address,
'phone': self.phone,
'age': self.age,
'active': self.active
}
def __init__(self, username, email, address, phone, age):
self.username = username
self.email = email
self.address = address
self.phone = phone
self.age = age
class Wakepark(db.Model):
__tablename__ = "wakeparks"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
created_date = db.Column(db.DateTime, default=func.now(), nullable=False)
active = db.Column(db.Boolean(), default=False, nullable=False)
name = db.Column(db.String(128), nullable=False)
description = db.Column(db.String(255), nullable=False)
lat = db.Column(db.Float(), nullable=True)
lng = db.Column(db.Float(), nullable=True)
instagram_handle = db.Column(db.String(128), nullable=True)
owner_id = db.Column(db.String(), default=True, nullable=False)
def __init__(
self,
name="",
lat="",
lng="",
description="",
instagram_handle="",
owner_id="google-oauth2|104755831296456998532",
):
self.name = name
self.description = description
self.lat = lat
self.lng = lng
self.instagram_handle = instagram_handle
self.owner_id = owner_id
def __repr__(self):
return (
f"<Wakepark id:{self.id},name:{self.name},owner:{self.owner_id}>")
def to_json(self):
ig_url = "https://www.instagram.com/"
return {
"id": self.id,
"name": self.name,
"owner_id": self.owner_id,
"location": {
"lat": self.lat,
"lng": self.lng
},
"description": self.description,
"social": {
"instagram": f"{ig_url}{self.instagram_handle}"
},
}
def to_dict(self):
return {
"id": self.id,
"name": self.name,
"lat": self.lat,
"lng": self.lng,
"description": self.description,
"instagram_handle": self.instagram_handle,
"owner_id": self.owner_id,
}
class User(db.Model):
__tablename__ = 'users'
id = db.Column(
db.Integer,
primary_key=True,
autoincrement=True,
)
username = db.Column(
db.String(128),
nullable=False,
)
email = db.Column(
db.String(128),
nullable=False,
)
active = db.Column(
db.Boolean(),
default=True,
nullable=False,
)
def __init__(self, username, email):
self.username = username
self.email = email
def to_json(self):
return {
'id': self.id,
'username': self.username,
'email': self.email,
'active': self.active,
}
class Admin(db.Model):
__tablename__ = 'admin'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
created_date = db.Column(db.DateTime, default=func.now(), nullable=False)
last_login_date = db.Column(db.DateTime, default=func.now(), nullable=False)
def __init__(self, username, email, password):
self.username = username
self.email = email
self.password = bcrypt.generate_password_hash(
password, current_app.config.get('BCRYPT_LOG_ROUND')
).decode()
def to_json(self):
return {
'id': self.id,
'username': self.username,
'email': self.email,
'active': self.active,
'created_date': self.created_date,
'last_login_date': self.last_login_date,
}
class Bovine(db.Model):
bovine_id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
name = db.Column(db.String(150), nullable=True)
date_of_birth = db.Column(db.String(15), nullable=False)
breed = db.Column(db.String(25), nullable=True)
actual_weight = db.Column(db.Numeric(7, 2), nullable=False)
is_beef_cattle = db.Column(db.Boolean(), nullable=True)
farm_id = db.Column(db.Integer, db.ForeignKey('farm.farm_id'))
batch_of_beef = db.Column(db.Integer, nullable=True)
__mapper_args__ = {'polymorphic_identity': 'bovine'}
def init(self, farm_id, name, date_of_birth, breed, actual_weight,
is_beef_cattle, batch_of_beef):
self.farm_id = farm_id
self.name = name
self.breed = breed
self.actual_weight = actual_weight
self.date_of_birth = date_of_birth
self.is_beef_cattle = is_beef_cattle
self.batch_of_beef = batch_of_beef
def to_json(self):
return {
'bovine_id': self.bovine_id,
'farm_id': self.farm_id,
'breed': self.breed,
'actual_weight': float(self.actual_weight),
'date_of_birth': str(self.date_of_birth),
'is_beef_cattle': self.is_beef_cattle,
'batch_of_beef': self.batch_of_beef
}
class User(db.Model):
__tablename__ = 'libros'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
titulo = db.Column(db.String(128), nullable=False)
autor = db.Column(db.String(128), nullable=False)
añodepublicacion = db.Column(db.String(128), nullable=False)
editorial = db.Column(db.String(128), nullable=False)
generoliterario = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
created_date = db.Column(db.DateTime, default=func.now(), nullable=False)
def to_json(self):
return {
'id': self.id,
'titulo': self.titulo,
'autor': self.autor,
'añodepublicacion': self.añodepublicacion,
'editorial': self.editorial,
'generoliterario': self.generoliterario,
'active': self.active
}
def __init__(
self, titulo, autor, añodepublicacion,
editorial, generoliterario
):
self.titulo = titulo
self.autor = autor
self.añodepublicacion = añodepublicacion
self.editorial = editorial
self.generoliterario = generoliterario
class User(db.Model):
"""
Define users table model and a User bean
parameter: a SQLAlchemy database
"""
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), nullable=False)
email = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
created_date = db.Column(db.DateTime, default=func.now(), nullable=False)
def __init__(self, username='', email=''):
self.username = username
self.email = email
def to_json(self):
return {
"id": self.id,
"username": self.username,
"email": self.email,
"active": self.active,
}
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
created_date = db.Column(db.DateTime, default=func.now(), nullable=False)
admin = db.Column(db.Boolean, default=False, nullable=False)
def __init__(self, username, email, password, admin=False):
self.username = username
self.email = email
self.password = bcrypt.generate_password_hash(
password, current_app.config.get("BCRYPT_LOG_ROUNDS")).decode()
self.admin = admin
def to_json(self):
return {
"id": self.id,
"username": self.username,
"email": self.email,
"active": self.active,
"admin": self.admin,
}
def encode_auth_token(self, user_id):
try:
payload = {
"exp":
datetime.datetime.utcnow() + datetime.timedelta(
days=current_app.config.get("TOKEN_EXPIRATION_DAYS"),
seconds=current_app.config.get("TOKEN_EXPIRATION_SECONDS"),
),
"iat":
datetime.datetime.utcnow(),
"sub":
user_id,
}
return jwt.encode(payload,
current_app.config.get("SECRET_KEY"),
algorithm="HS256")
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
"""
Decodes the auth token - :param auth_token: - :return: integer|string
"""
try:
payload = jwt.decode(auth_token,
current_app.config.get("SECRET_KEY"))
return payload["sub"]
except jwt.ExpiredSignatureError:
return "Signature expired. Please log in again."
except jwt.InvalidTokenError:
return "Invalid token. Please log in again."
class Product(db.Model):
__tablename__ = 'products'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
nombre = db.Column(db.String(128), nullable=False)
cantidad = db.Column(db.Integer(), nullable=False)
precio = db.Column(db.Float(), nullable=False)
descripcion = db.Column(db.String(128), nullable=False)
categoria = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
def to_json(self):
return {
'id': self.id,
'nombre': self.nombre,
'cantidad': self.cantidad,
'precio': self.precio,
'descripcion': self.descripcion,
'categoria': self.categoria,
'active': self.active
}
def __init__(self, nombre, cantidad, precio, descripcion, categoria):
self.nombre = nombre
self.cantidad = cantidad
self.precio = precio
self.descripcion = descripcion
self.categoria = categoria
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), nullable=False)
email = db.Column(EmailType, nullable=False, unique=True)
registered_on = db.Column(db.DateTime, nullable=False)
company_id = db.Column(db.Integer,
db.ForeignKey('company.id'),
nullable=False)
company = db.relationship('Company', back_populates='user')
active = db.Column(db.Boolean(), default=True, nullable=False)
password = db.Column(db.String(255), unique=False, nullable=False)
def __init__(self, username, email, company_id, password):
self.username = username
self.email = email
self.company_id = company_id
self.password = bcrypt.generate_password_hash(
password, current_app.config.get('BCRYPT_LOG_ROUNDS')).decode()
self.registered_on = datetime.datetime.now()
def to_json(self):
return {
'username': self.username,
'email': self.email,
'company_id': self.company_id,
'password': self.password,
'active': self.active
}
def encode_auth_token(self, user_id):
try:
payload = {
'exp':
datetime.datetime.utcnow() + datetime.timedelta(
days=current_app.config.get('TOKEN_EXPIRATION_DAYS'),
seconds=current_app.config.get(
'TOKEN_EXPIRATION_SECONDS')),
'iat':
datetime.datetime.utcnow(),
'sub':
user_id
}
return jwt.encode(payload,
current_app.config.get('SECRET_KEY'),
algorithm='HS256')
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
try:
payload = jwt.decode(auth_token,
current_app.config.get('SECRET_KEY'))
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
class Station(db.Model):
__tablename__ = "stations"
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# here id will be the station_id, so no auto-incrememnt
id = db.Column(db.Integer(), primary_key=True, nullable=False)
station_name = db.Column(db.String(128), nullable=True)
available_docks = db.Column(db.Integer(), nullable=True)
total_docks = db.Column(db.Integer(), nullable=True)
latitude = db.Column(db.Float(), nullable=True)
longitude = db.Column(db.Float(), nullable=True)
status_value = db.Column(db.String(128), nullable=True)
status_key = db.Column(db.Integer(), nullable=True)
available_bikes = db.Column(db.Integer(), nullable=True)
st_address_1 = db.Column(db.String(128), nullable=True)
st_address_2 = db.Column(db.String(128), nullable=True)
city = db.Column(db.String(128), nullable=True)
postal_code = db.Column(db.String(128), nullable=True)
location = db.Column(db.String(128), nullable=True)
altitude = db.Column(db.String(128), nullable=True)
land_mark = db.Column(db.String(128), nullable=True)
test_station = db.Column(db.Boolean(), nullable=True)
last_communication_time = db.Column(db.String(128), nullable=True)
def __init__(self, id, station_name, available_docks, total_docks,
latitude, longitude, status_value, status_key,
available_bikes, st_address_1, st_address_2, city,
postal_code, location, altitude, land_mark, test_station,
last_communication_time):
self.id = id
self.station_name = station_name
self.available_docks = available_docks
self.total_docks = total_docks
self.latitude = latitude
self.longitude = longitude
self.status_value = status_value
self.status_key = status_key
self.available_bikes = available_bikes
self.st_address_1 = st_address_1
self.st_address_2 = st_address_2
self.city = city
self.postal_code = postal_code
self.location = location
self.altitude = altitude
self.land_mark = land_mark
self.test_station = test_station
self.last_communication_time = last_communication_time
def from_dict(self, data):
for field in [
'station_name', 'available_docks', 'total_docks', 'latitude',
'longitude', 'status_value', 'status_key', 'available_bikes',
'st_address_1', 'st_address_2', 'city', 'postal_code',
'location', 'altitude', 'land_mark', 'test_station',
'last_communication_time'
]:
if field in data:
setattr(self, field, data[field])
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(128), unique=True, nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
def __init__(self, email):
self.email = email
