class ProjectEmployeeRole(db.Model):
__tablename__ = 'Project_employee_role'
rate = db.Column(db.Float(asdecimal=True), nullable=False)
employee_id = db.Column(db.ForeignKey('Employee.id'),
primary_key=True,
nullable=False,
index=True)
project_id = db.Column(db.ForeignKey('Project.id'),
primary_key=True,
nullable=False,
index=True)
employee_role_id = db.Column(db.ForeignKey('Employee_role.id'),
nullable=False,
index=True)
employee = db.relationship('Employee', lazy=True)
employee_role = db.relationship('EmployeeRole', lazy=True)
project = db.relationship('Project', lazy=True)
def __init__(self, project_id, employee_id, employee_role_id, rate):
self.project_id = project_id
self.employee_id = employee_id
self.employee_role_id = employee_role_id
self.rate = rate
class User(db.Model):
__tablename__ = 'USERS'
id = db.Column(db.Integer, primary_key=True)
ci = db.Column(db.String(14))
nombres = db.Column(db.String(140))
telefono = db.Column(db.String(14))
username = db.Column(db.String(24))
password = db.Column(db.String(24))
grupo = db.Column(db.Integer, db.ForeignKey('GRUPOS.id'))
denuncia = db.relationship('Denuncia')
formulario = db.relationship('Formulario')
def __init__(self,
ci=None,
nombre=None,
telefono=None,
username=None,
password=None,
grupo=None):
self.ci = ci
self.nombres = nombre
self.telefono = telefono
self.username = username
self.password = password
self.grupo = grupo
def __create_password(self, passw):
return generate_password_hash(passw)
def verify_password(self, passw):
return check_password_hash(self.password, passw)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100))
pwdhash = db.Column(db.String())
days = db.relationship('Day', backref='user', lazy='dynamic')
exercises = db.relationship('Exercise', backref='user', lazy='dynamic')
def __init__(self, username, password):
self.username = username
self.pwdhash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.pwdhash, password)
@property
def is_authenticated(self):
return True
@property
def is_active(self):
return True
@property
def is_anonymous(self):
return False
def get_id(self):
return str(self.id)
class Customer_Ids(db.Model):
__tablename__ = 'customer_ids'
customer_id = db.Column(db.String(50), primary_key=True)
customer_aliases = db.relationship('Customer_Aliases',
backref='my_customer_id',
lazy=True)
customer_so_numbers = db.relationship('Sales_Orders',
backref='my_customer_id',
lazy=True)
class EmployeeReport(db.Model):
__tablename__ = 'Employee_report'
employee_id = db.Column(db.ForeignKey('Employee.id'),
primary_key=True,
nullable=False)
hours_sum = db.Column(db.Integer, nullable=False)
report_sprint_id = db.Column(db.ForeignKey('Report.sprint_id'),
primary_key=True,
nullable=False,
index=True)
employee = db.relationship('Employee')
report_sprint = db.relationship('Report')
class Lawyer(db.Model):
__tablename__='lawyers'
lawyers_id = db.Column(db.Integer, primary_key=True)
lawyers_name = db.Column(db.String(30), unique=True, nullable=False)
lawyers_password = db.Column(db.String(30), unique=False, nullable=False)
lawyers_email = db.Column(db.String(100), unique=True, nullable=True)
lawyers_rut = db.Column(db.String(15), unique=True, nullable=False)
lawyers_phone = db.Column(db.Integer, unique=True, nullable= True)
lawyers_field = db.Column(db.String(15), unique=False, nullable=False)
lawyers_title = db.Column(db.Integer, unique=False, nullable=False)
lawyers_file_speciality = db.Column(db.Integer, unique=False, nullable=True )
lawyers_bank = db.Column(db.String(30), unique=False, nullable=False)
lawyers_account = db.Column(db.String(15), unique=False, nullable=False)
lawyers_bank_number = db.Column(db.Integer, unique=True, nullable=False)
lawyers = db.relationship('User', backref='lawyers')
def __repr__(self):
return '<Lawyer %r>' % self.lawyers_id, self.lawyers_name, self.lawyers_password, self.lawyers_email, self.lawyers_rut, self.lawyers_phone, self.lawyers_field, self.lawyers_title, self.lawyers_file_speciality, self.lawyers_bank, self.lawyers_account, self.lawyers_bank_number
def serialize(self):
return {
"lawyers_id": self.lawyers_id,
"lawyers_name": self.lawyers_name,
"lawyers_password": self.lawyers_password,
"lawyers_email": self.lawyers_email,
"lawyers_rut": self.lawyers_rut,
"lawyers_phone": self.lawyers_phone,
"lawyers_field": self.lawyers_field,
"lawyers_title": self.lawyers_title,
"lawyers_file_speciality": self.lawyers_file_speciality,
"lawyers_bank": self.lawyers_bank,
"lawyers_account": self.lawyers_account,
"lawyers_bank_number": self.lawyers_bank_number
}
class Client(db.Model):
__tablename__='clients'
clients_id = db.Column(db.Integer, primary_key=True)
clients_username = db.Column(db.String(30), unique=True, nullable=False)
clients_email = db.Column(db.String(100), unique=True, nullable=True)
clients_password = db.Column(db.String(100), unique=False, nullable=False)
clients_phone = db.Column(db.Integer, unique=True, nullable=True)
clients_rut = db.Column(db.String(30), unique=True, nullable=True)
clients_address = db.Column(db.String(80), unique=False, nullable=True)
clients_profession = db.Column(db.String(30), unique=False, nullable=True)
clients_nationality = db.Column(db.String(30), unique=False, nullable=True)
clients_civil_status = db.Column(db.String(20), unique=False, nullable=True)
clients_avatar = db.Column(db.Integer, unique=False, nullable=True, default=1)
cases = db.relationship('Case', backref='client')
def __repr__(self):
return '<Client %r>' % self.clients_id, self.clients_username, self.clients_email, self.clients_password, self.clients_phone, self.clients_rut, self.clients_address, self.clients_profession, self.clients_nationality, self.clients_civil_status, self.clients_avatar
def serialize(self):
return {
"clients_id": self.clients_id,
"clients_username": self.clients_username,
"clients_email": self.clients_email,
"clients_password": self.clients_password,
"clients_phone": self.clients_phone,
"clients_rut": self.clients_rut,
"clients_address": self.clients_address,
"clients_profession": self.clients_profession,
"clients_nationality": self.clients_nationality,
"clients_civil_status": self.clients_civil_status,
"clients_avatar": self.clients_avatar
}
class Business(db.Model):
id = db.Column(db.Integer, primary_key=True)
#google information
business_name = db.Column(db.String(500))
place_id = db.Column(db.String(200), unique=True, nullable=False)
#crowdsourced data
avg_mask_required = db.Column(db.Boolean) # boolean
avg_mask_enforced = db.Column(db.Float) #0 to 10
avg_busy = db.Column(db.Float)
avg_social_distance = db.Column(db.Float) #0 to 10
score = db.Column(db.Float)
reviews = db.relationship('Review', backref='Business', lazy=True)
def __repr__(self): #returns json object for javascript
b = {'business_name' : self.business_name,
'avg_mask_required' : self.avg_mask_required,
'avg_busy' : self.avg_busy,
'avg_mask_enforced' : self.avg_mask_enforced,
'avg_social_distance' : self.avg_social_distance,
'score' : self.score}
return json.dumps(b)
class Denuncia(db.Model):
__tablename__ = 'DENUNCIAS'
id = db.Column(db.Integer, primary_key=True)
tipo = db.Column(db.String(80))
foto = db.Column(db.String(180))
descripcion = db.Column(db.String(240))
lat = db.Column(db.Float)
lon = db.Column(db.Float)
user = db.Column(db.Integer, db.ForeignKey('USERS.id'))
image = db.relationship('Image')
def __init__(self,
tipo=None,
foto=None,
descripcion=None,
lat=None,
lon=None,
user=None):
self.tipo = tipo
self.foto = foto
self.descripcion = descripcion
self.lat = lat
self.lon = lon
self.user = user
class Predio(db.Model):
__tablename__ = 'PREDIOS'
id = db.Column(db.Integer, primary_key=True)
condgnrl = db.Column(db.String(240))
direccion = db.Column(db.String(120))
elimres = db.Column(db.String(120))
numadultos = db.Column(db.Integer)
numninios = db.Column(db.Integer)
proposito = db.Column(db.String(120))
protecventana = db.Column(db.String(120))
suministroagua = db.Column(db.String(120))
form = db.Column(db.Integer, db.ForeignKey('FORMULARIOS.id'))
formulario = db.relationship('Criadero')
def __init__(self,
condgnrl=None,
direccion=None,
elimres=None,
numadultos=None,
numninios=None,
proposito=None,
protecventana=None,
suministroagua=None,
form=None):
self.condgnrl = condgnrl
self.direccion = direccion
self.elimres = elimres
self.numadultos = numadultos
self.numninios = numninios
self.proposito = proposito
self.protecventana = protecventana
self.suministroagua = suministroagua
self.elimres = elimres
self.form = form
class Token(db.Model):
"""公众号类
开发平台用户绑定的公众号, 包含对应的公众号信息
Attributes:
access_token (str): 用来公众号权限的access_Ttoken
account (str): 公众号账户外键
account_id (str): 对应的账户id
app_id (str): 公众号app_id
app_secret (str): 公众号app_secret
expired_time (int): 公众号access_token过期时间戳
id (int): 自增键
token (str): 公众号接入的token, 用于验证
wechat_id (str): 公众号id
"""
id = db.Column(db.Integer, primary_key=True)
app_id = db.Column(db.String(255), unique=True)
app_secret = db.Column(db.String(255))
wechat_id = db.Column(db.String(255))
token = db.Column(db.String(255))
access_token = db.Column(db.String(255))
expired_time = db.Column(db.Integer)
account_id = db.Column(db.Integer, db.ForeignKey('account.id'))
account = db.relationship('Account',
backref=db.backref('tokens', lazy='dynamic'))
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True, nullable=True)
item = db.relationship("Item", cascade="all, delete-orphan")
def __init__(self, name):
self.name = name
class Videos(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
naslov = db.Column(db.String(80), nullable=False)
podforum = db.Column(db.String(30), nullable=False)
objavljeno = db.Column(db.DateTime(),
nullable=False,
default=lambda: datetime.datetime.utcnow())
slika = db.Column(db.String(255), nullable=False)
dl_link = db.Column(db.String(80), nullable=False)
objavio = db.Column(db.Integer(), db.ForeignKey("users.id"))
url_view = db.Column(db.String(60),
nullable=False,
unique=True,
default=lambda nbytes=16: secrets.token_hex(nbytes))
korisnici = db.relationship('Users',
backref=db.backref('objavio', lazy='dynamic'))
def __init__(self, naslov, podforum, dl_link, objavio=1):
self.naslov = naslov
self.podforum = podforum
self.dl_link = dl_link
self.objavio = objavio
self.slika = ""
def __repr__(self):
return str(self.id)
def __str__(self):
return str(self.id)
def get_time_for_index(podforum):
obj = Videos.query.filter(Videos.podforum == podforum).order_by(
Videos.id.desc()).first()
vreme = (datetime.datetime.utcnow() - obj.objavljeno).total_seconds()
return vreme
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(64), unique=True)
password_hash = db.Column(db.String(255))
name = db.Column(db.String(64))
slug = db.Column(db.String(64), unique=True)
active = db.Column(db.Boolean, default=True)
created_timestamp = db.Column(db.DateTime, default=datetime.datetime.now)
entries = db.relationship('Entry', backref='author', lazy='dynamic')
admin = db.Column(db.Boolean, default=False)
def is_admin(self):
return self.admin
def __init__(self, *args, **kwargs):
super(User, self).__init__(*args, **kwargs)
self.generate_slug()
def __repr__(self):
return '<User: {}>'.format(self.name)
def generate_slug(self):
if self.name:
self.slug = slugify(self.name)
# Flask-Login interface...
def get_id(self):
return self.id
def is_authenticated(self):
return True
def is_active(self):
return self.active
def is_anonymous(self):
return False
# Bcrypt-related
@staticmethod
def make_password(plaintext):
return bcrypt.generate_password_hash(plaintext)
def check_password(self, raw_password):
return bcrypt.check_password_hash(self.password_hash, raw_password)
@classmethod
def create(cls, email, password, **kwargs):
return User(email=email,
password_hash=User.make_password(password),
**kwargs)
@staticmethod
def authenticate(email, password):
user = User.query.filter(User.email == email).first()
if user and user.check_password(password):
return user
return False
class Objects(db.Model):
"""
Vehicles
"""
nid = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=True)
valid_from = db.Column(db.DateTime, default=datetime.utcnow)
valid_to = db.Column(db.DateTime)
created_by = db.Column(db.Integer)
provider_id = db.Column(db.Integer, db.ForeignKey('providers.nid'))
created = db.Column(db.DateTime(timezone=True))
nofqueries = db.Column(db.Integer)
nofsqueries = db.Column(db.Integer)
lastquery = db.Column(db.DateTime(timezone=True))
active = db.Column(db.Boolean)
# backref for locations. Attention at backref!!!
locations = db.relationship('Location', backref='object', lazy='dynamic')
def __init__(
self,
name,
):
self.name = name
def __repr__(self):
return 'Vehicle : %s' % (self.name, )
class Feature(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255))
description = db.Column(db.Text(2048))
priority = db.Column(db.Integer)
target_date = db.Column(db.Date)
area_id = db.Column(db.Integer, db.ForeignKey('area.id'))
area = db.relationship('Area',
backref=db.backref('features', lazy='dynamic'))
client_id = db.Column(db.Integer, db.ForeignKey('client.id'))
client = db.relationship('Client',
backref=db.backref('features', lazy='dynamic'))
def __repr__(self):
return '<Feature %d>' % self.id
class Formulario(db.Model):
__tablename__ = 'FORMULARIOS'
id = db.Column(db.Integer, primary_key=True)
user = db.Column(db.Integer, db.ForeignKey('USERS.id'))
formulario = db.relationship('Predio')
def __init__(self, user):
self.user = user
class Grupo(db.Model):
__tablename__ = 'GRUPOS'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(80))
users = db.relationship('User')
def __init__(self, nombre):
self.nombre = nombre
class Person(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(150))
email = db.Column(db.String(150))
debts = db.relationship('Debt')
def __init__(self, name, email):
self.name = name
self.email = email
class City(db.model): #=> Base
__tablename__ = 'city'
id = db.Column(db.Integer, primary_key=True)
cityname = db.Column(db.String(32))
dusts = db.relationship("City", backref='city')
def __repr__(self):
return f"City {self.id}"
class Entry(db.Model):
STATUS_PUBLIC = 0
STATUS_DRAFT = 1
STATUS_DELETED = 2
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100))
slug = db.Column(db.String(100), unique=True)
body = db.Column(db.Text)
status = db.Column(db.SmallInteger, default=STATUS_PUBLIC)
created_timestamp = db.Column(db.DateTime, default=datetime.datetime.now)
modified_timestamp = db.Column(
db.DateTime,
default=datetime.datetime.now,
onupdate=datetime.datetime.now,
)
author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
tags = db.relationship('Tag',
secondary=entry_tags,
backref=db.backref('entries', lazy='dynamic'))
comments = db.relationship('Comment', backref='entry', lazy='dynamic')
@property
def tag_list(self):
return ', '.join(tag.name for tag in self.tags)
@property
def tease(self):
return self.body[:100]
def __init__(self, *args, **kwargs):
super(Entry, self).__init__(*args, **kwargs)
self.generate_slug()
def generate_slug(self):
self.slug = ''
if self.title:
self.slug = slugify(self.title)
def __repr__(self):
return '<Entry: {}>'.format(self.title)
class JFW_Clients(db.Model):
__tablename__ = 'jfw_clients'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(5), nullable=False)
firstname = db.Column(db.String(50), nullable=False)
lastname = db.Column(db.String(50), nullable=False)
id_card = db.Column(db.String(50), nullable=False)
company = db.Column(db.String(255))
filenumber = db.Column(db.Integer)
phone = db.Column(db.Integer)
mobile = db.Column(db.Integer)
email = db.Column(db.String(255))
street = db.Column(db.String(255), nullable=False)
city = db.Column(db.String(255), nullable=False)
country = db.Column(db.String(100), nullable=False)
postcode = db.Column(db.String(50))
registered = db.Column(db.DateTime, nullable=False)
projects = db.relationship('JFW_Projects',
backref='client',
lazy='dynamic')
def __repr__(self):
return "<{} - {} - {}>".format(self.id, self.firstname, self.lastname)
def __init__(self,
title,
firstname,
lastname,
id_card,
street,
city,
country,
postcode=None,
company=None,
filenumber=0,
phone=0,
mobile=0,
email=None):
self.title = title
self.firstname = firstname
self.lastname = lastname
self.id_card = id_card
self.company = company
self.filenumber = filenumber
self.phone = phone
self.mobile = mobile
self.email = email
self.street = street
self.city = city
self.country = country
self.postcode = postcode
self.registered = datetime.utcnow()
class Shoppinglists(db.Model):
__tablename__="Shoppinglists"
id= db.Column(db.Integer,primary_key=True)
shoppinglist_name=db.Column(db.String(255),unique=True)
user=db.Column(db.String(255))
products=db.relationship("Product",backref="Shoppinglists")
def __init__(self,shoppinglist_name,user):
self.shoppinglist_name=shoppinglist_name
self.user=user
def __repr__(self):
return '<Shoppinglists %d>'% self.id
class JFW_Categories(db.Model):
__tablename__ = 'jfw_categories'
id = db.Column(db.Integer, primary_key=True)
category = db.Column(db.String(50), nullable=False, unique=True)
projects = db.relationship('JFW_Projects',
backref='category',
lazy='dynamic')
def __init__(self, category):
self.category = category
class JFW_Status(db.Model):
__tablename__ = 'jfw_status'
id = db.Column(db.Integer, primary_key=True)
status = db.Column(db.String(50), nullable=False, unique=True)
projects = db.relationship('JFW_Projects',
backref='status',
lazy='dynamic')
def __init__(self, status):
self.status = status
class Category(db.Model):
__tablename__ = 'categories'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
products = db.relationship('Product', backref='category', lazy=True)
def __init__(self, name):
self.name = name
def __repr__(self):
return '<Category %r>' % (self.name)
class Products(db.Model):
id = db.Column(db.Integer, autoincrement=True)
title = db.Column(db.VARCHAR, nullable=False)
asin = db.Column(db.VARCHAR, nullable=False, primary_key=True)
reviewses = db.relationship('Reviews', backref='products', lazy=True)
def __repr__(self):
return self.asin
def to_dict(self):
return {'id': self.id, 'title': self.title, 'asin': self.asin}
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
subscriptions = db.relationship('Subscription',
backref='subscribed',
lazy=True)
def __repr__(self):
return f"User('{self.id}', '{self.username}', '{self.email}')"
class Exercise(db.Model):
id = db.Column(db.Integer, primary_key=True)
exr_mg = db.Column(db.String(120))
exr_name = db.Column(db.String(120), nullable=False)
exr_reps = db.Column(db.Integer)
exr_sets = db.Column(db.Integer)
exr_val = db.Column(db.Integer)
day_id = db.Column(db.Integer, db.ForeignKey('day.id'))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
weekly_values = db.relationship('Weekly_Value',
backref='exercise',
lazy='dynamic')
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
profile_image = db.Column(db.String(30),
nullable=False,
default='howwwwwhy.png')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.profile_image}')"
