class ComplianceRuleResults(db.Model):
__tablename__ = 'compliance_rule_results'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
ruleId = db.Column('rule_id',
db.Integer,
db.ForeignKey('rules.id'),
nullable=False)
provider = db.Column(db.String(100))
region = db.Column(db.String(100))
result = db.Column(db.String(100))
message = db.Column(db.Text)
timestamp = db.Column(db.Date)
rule = relationship("Rules", backref="rules")
def __init__(self, ruleId, provider, region, result, message, timestamp):
self.ruleId = ruleId
self.provider = provider
self.region = region
self.result = result
self.message = message
self.timestamp = timestamp
def __repr__(self):
return '<Result {} {} {}>'.format(self.ruleId, self.result,
self.message)
def toString(self):
return ({
'name': self.ruleId,
'region': self.region,
'message': self.message,
'provider': self.provider,
'rule': self.rule.toString(),
'result': self.result
})
class Article(Base):
__tablename__='article'
by=db.Column(db.String(64))
url=db.Column(db.String(128))
title=db.Column(db.String(128))
score=db.Column(db.Integer)
def __init__(self,by,url,title,score):
self.url=url
self.title=title
self.score=score
self.by=by
class ServiceInstance(db.Model):
__tablename__ = "service_instance"
service_id = db.Column(db.Integer,
db.ForeignKey('service_registry.id'),
primary_key=True)
host = db.Column(db.String(255), nullable=False, primary_key=True)
port = db.Column(db.String(255), nullable=False, primary_key=True)
health = db.Column(db.Integer)
created_on = db.Column(db.DateTime, server_default=db.func.now())
updated_on = db.Column(db.DateTime,
server_default=db.func.now(),
onupdate=db.func.now())
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(120), unique=True)
created_at = db.Column(db.DateTime, nullable=False)
categories = db.relationship('Category', backref='user', lazy='dynamic')
items = db.relationship('Item', backref='user', lazy='dynamic')
def __init__(self, username, email):
self.username = username
self.email = email
self.created_at = datetime.datetime.utcnow()
class Announcement(db.Model):
__tablename__ = 'announcements'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.Unicode, nullable=False)
description = db.Column(db.Unicode, nullable=True)
url = db.Column(db.String(256), nullable=True)
token = db.Column(db.String(32), nullable=False)
mobile_number = db.Column(db.String(13), nullable=True)
owner = db.Column(db.Unicode, nullable=True)
place = db.Column(db.Unicode, nullable=True)
rent = db.Column(db.Unicode, nullable=True)
deposit_amount = db.Column(db.Unicode, nullable=True)
price = db.Column(db.Unicode, nullable=True)
lat = db.Column(db.Float, nullable=True)
long = db.Column(db.Float, nullable=True)
has_loan = db.Column(db.Boolean, default=False)
size_amount = db.Column(db.Integer, nullable=False)
type = db.Column(db.Unicode, nullable=False)
rooms_num = db.Column(db.Integer, nullable=True, default=1)
build_year = db.Column(db.Integer, nullable=True)
market = db.Column(db.String(32), nullable=False)
created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
def __repr__(self):
return '<Announcement {} {}>'.format(self.mobile_number, self.created_at)
def to_dict(self):
data = {
'id': self.id,
'title': self.title,
'url': self.url,
'lat': self.lat,
'long': self.long,
'place': self.place,
'rent': self.rent,
'deposit_amount': self.deposit_amount,
'price': self.price,
'description': self.description,
'mobile_number': self.mobile_number,
'size_amount': self.size_amount,
'type': self.type,
'rooms_num': self.rooms_num,
'build_year': self.build_year,
'owner': self.owner,
'created_at': self.created_at
}
return data
class User2(db.Model):
__tablename__ = 'users2'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(), unique=True, nullable=False)
password = db.Column(db.String(), nullable=False)
email = db.Column(db.String(), unique=True)
def __init__(self, username, password, email):
self.username = username
self.password = password
self.email = email
def __repr__(self):
return "<E-mail %s>" % self.email
class Tenant(db.Model):
__tablename__ = 'user'
id = db.Column('id', db.String(60), primary_key=True, nullable=False)
fname = db.Column('fname', db.String(60), nullable=False)
mname = db.Column('mname', db.String(60), nullable=False)
lname = db.Column('lname', db.String(60), nullable=False)
sex = db.Column(db.String(6), nullable=False)
addressHome = db.Column('addressHome', db.String(60), nullable=False)
course = db.Column('course', db.String(60), nullable=False)
birth_date = db.Column(db.DATE, nullable=False)
def __init__(self,
id='',
fname='',
mname='',
lname='',
sex='',
addressHome='',
course='',
birth_date=""):
self.id = id
self.fname = fname
self.mname = mname
self.lname = lname
self.sex = sex
self.addressHome = addressHome
self.course = course
self.birth_date = birth_date
class ServiceRegistry(db.Model):
__tablename__ = "service_registry"
id = db.Column(db.Integer, primary_key=True)
service = db.Column(db.String(255), unique=True, nullable=False)
created_on = db.Column(db.DateTime, server_default=db.func.now())
updated_on = db.Column(db.DateTime,
server_default=db.func.now(),
onupdate=db.func.now())
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
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)
@login.user_loader
def load_user(id):
return User.query.get(int(id))
class Post2(Base):
__tablename__ = 'post2'
title = db.Column(db.String(64))
body = db.Column(db.Text)
user_id = db.Column(db.Integer, db.ForeignKey('user2.id'))
def __init__(self, user_id, title, body):
self.user_id = user_id
self.title = title
self.body = body
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True)
created_at = db.Column(db.DateTime, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
items = db.relationship('Item', backref='category', lazy='dynamic')
def __init__(self, username, email):
self.name = name
self.created_at = datetime.datetime.utcnow()
class User2(Base):
__tablename__= 'users2'
username= db.Column(db.String(), unique=True, nullable=False)
password= db.Column(db.String(), nullable=False)
email= db.Column(db.String(), unique=True)
def __init__(self, username, password, email):
self.username=username
self.password=bcrypt.generate_password_hash(password=password)
self.email=email
def check_password_hash(self,password):
if bcrypt.check_password_hash(pw_hash=self.password,password=password):
return True
else:
return False
def __repr__(self):
return "<E-mail %s>" % self.email
class Rules(db.Model):
__tablename__ = 'rules'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100))
description = db.Column(db.String(100))
severity = db.Column(db.String(100))
rgroup = db.Column(db.String(100))
entity_type = db.Column(db.String(100))
provider = db.Column(db.String(100))
def __init__(self, name, description, severity, rgroup, entity, provider):
self.name = name
self.description = description
self.severity = severity
self.rgroup = rgroup
self.entity = entity
self.provider = provider
def toString(self):
groups = self.rgroup.split(",")
return ({
'name': self.description,
'description': self.description,
'severity': self.severity,
'groups': groups,
'provider': self.provider
})
def __repr__(self):
return '<Rule {} {}>'.format(seld.id, self.name)
class Item(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.Text, unique=True)
created_at = db.Column(db.DateTime, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
def __init__(self, username, email):
self.name = name
self.description = description
self.created_at = datetime.datetime.utcnow()
class NotaMateria(db.Model):
__tablename__ = 'notamateria'
__table_args__ = {'extend_existing': True}
notamateria_id = db.Column(db.Integer, primary_key=True)
alumno_fk = db.Column(db.Integer)
nombremateria = db.Column(db.String(2))
notafinal = db.Column(db.Integer)
def __init__(self, alumno, nombremateria, notafinal):
self.alumno_fk = alumno,
self.nombremateria = nombremateria,
self.notafinal = notafinal
def save(self):
db.session.add(self)
db.session.commit()
def __repr__(self):
return '<id {}>'.format(self.notamateria_id)
@staticmethod
def buscarNotasMaterias():
#NotaMateria.query(func.count(User.id))
return NotaMateria.query.order_by(NotaMateria.alumno_fk).all()
@staticmethod
def buscarNotaMateriaByNotamateriaID(notamateria_id):
return NotaMateria.query.filter_by(
notamateria_id=notamateria_id).first()
@staticmethod
def getNotasMateriasByAlumnoID(id):
return NotaMateria.query.filter_by(alumno_fk=id).order_by(
NotaMateria.nombremateria).all()
'''query = NotaMateria.query.filter(User.name.like('%ed')).order_by(User.id)'''
'''return NotaMateria.query.filter_by(alumno_fk=id).first_or_404(description='No existe datos con el ID ={}'.format(id))'''
#session.query(User).filter_by(name='jack').count() hacer esto para verificar si fue eliminado
def delete(self):
db.session.delete(self)
db.session.commit()
def serializar(self):
return {
'notamateria_id': self.notamateria_id,
'alumno': self.alumno_fk,
'nombremateria': self.nombremateria,
'notafinal': self.notafinal
}
class Incubator(db.Model):
__tablename__ = 'incubators'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), unique=False, index=True, default='Incubator')
rows = db.Column(db.Integer, nullable=False)
columns = db.Column(db.Integer, nullable=False)
date_created = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
balot = db.Column(db.Integer, default=0)
freska = db.Column(db.Integer, default=0)
matra = db.Column(db.Integer, default=0)
echo = db.Column(db.Integer, default=0)
penoy = db.Column(db.Integer, default=0)
def __repr__(self):
return '<Role %r>' % self.name
class User2(Base):
__tablename__ = 'user2'
username = db.Column(db.String(), unique=True, nullable=False)
password = db.Column(db.String(), nullable=False)
email = db.Column(db.String(), unique=True)
posts = db.relationship('Post2', backref='author', lazy='dynamic')
is_admin = db.Column(db.Boolean, default=False)
is_active = db.Column(db.Boolean, default=False)
def __init__(self, username, password, email):
self.username = username
self.password = bcrypt.generate_password_hash(password=password)
self.email = email
def check_password_hash(self, password):
if bcrypt.check_password_hash(pw_hash=self.password,
password=password):
return True
else:
return False
def __repr__(self):
return "<E-mail %s>" % self.email
class Location(db.Model):
"""A physical location of a drop point at some point in time.
Drop points may be relocated at any time for whatever reason. For
analysis after an event and optimization of the drop point locations
for the next event at the same venue, drop point locations are tracked
over time.
Each location has a start time indicating the placement of the drop
point at that location. If a drop point is relocated, a new location
with the respective start time is added. If the start time is null,
the drop point has been there since the creation of the universe.
If the human-readable description as well as the coordinates both are
null, the location of that drop point is unknwon.
"""
max_description = 140
loc_id = db.Column(db.Integer, primary_key=True)
dp_id = db.Column(db.Integer,
db.ForeignKey("drop_point.number"),
nullable=False)
dp = db.relationship("DropPoint")
time = db.Column(db.DateTime)
description = db.Column(db.String(max_description))
lat = db.Column(db.Float)
lng = db.Column(db.Float)
level = db.Column(db.Integer)
def __init__(self,
dp,
time=None,
description=None,
lat=None,
lng=None,
level=None):
errors = []
if not isinstance(dp, model.drop_point.DropPoint):
errors.append({"Location": _("Not given a drop point object.")})
raise ValueError(errors)
self.dp = dp
if time and not isinstance(time, datetime):
errors.append({"Location": _("Start time not a datetime object.")})
if isinstance(time, datetime) and time > datetime.today():
errors.append({"Location": _("Start time in the future.")})
if dp.locations and isinstance(time, datetime) and \
time < dp.locations[-1].time:
errors.append({"Location": _("Location older than current.")})
self.time = time if time else datetime.today()
try:
self.lat = float(lat)
except (TypeError, ValueError):
errors.append(
{"lat": _("Latitude is not a floating point number.")})
else:
if not -90 < self.lat < 90:
errors.append(
{"lat": _("Latitude is not between 90 degrees N/S.")})
try:
self.lng = float(lng)
except (TypeError, ValueError):
errors.append(
{"lng": _("Longitude is not a floating point number.")})
else:
if not -180 < self.lng < 180:
errors.append(
{"lng": _("Longitude is not between 180 degrees W/E.")})
try:
self.level = int(level)
except (TypeError, ValueError):
errors.append({"level": _("Level is not a number.")})
try:
self.description = str(description)
except (TypeError, ValueError):
errors.append(
{"description": _("Location description is not a string.")})
else:
if len(self.description) > self.max_description:
errors.append(
{"description": _("Location description is too long.")})
if errors:
raise ValueError(*errors)
db.session.add(self)
def __repr__(self):
return "Location %s of drop point %s (%s since %s)" % (
self.loc_id, self.dp_id, self.description, self.time)
class User(db.Model, UserMixin):
"""
The User class represents a user that can access the web interface. Each
user has a login (i.e. user name), a password and may have the right to
visit drop points, to edit drop points or admin rights (i.e. adding or
removing other users or changing their credentials).
"""
_id = db.Column("id", db.Integer, primary_key=True)
name = db.Column("name", db.String(MAXLENGTH_NAME), nullable=False,
unique=True)
_password = db.Column("password", db.LargeBinary, nullable=False)
_token = db.Column("token", db.String(TOKEN_LENGTH), nullable=False)
can_visit = db.Column("can_visit", db.Boolean, nullable=False, default=True)
can_edit = db.Column("can_edit", db.Boolean, nullable=False, default=False)
is_admin = db.Column("is_admin", db.Boolean, nullable=False, default=False)
is_active = db.Column("is_active", db.Boolean, nullable=False, default=True)
must_reset_pw = db.Column("must_reset_pw", db.Boolean, nullable=False,
default=True)
def __init__(self, name=None, password=None, can_visit=True, can_edit=False,
is_admin=False, must_reset_pw=True):
errors = []
if not (name and password):
errors.append({"user": _("User needs a name and a password.")})
try:
self.name = str(name)
except (TypeError, ValueError):
errors.append({"user": _("User name is not a string.")})
else:
if len(name) > MAXLENGTH_NAME:
errors.append({"user": _("User name is too long.")})
try:
self._password = bcrypt.generate_password_hash(password)
except (TypeError, ValueError):
errors.append({"user": _("Password hashing failed.")})
self._token = make_secure_token()
self.can_visit = can_visit
self.can_edit = can_edit
self.is_admin = is_admin
self.must_reset_pw = must_reset_pw
if errors:
raise ValueError(*errors)
@property
def user_id(self):
return self._id
@property
def is_authenticated(self):
return True
def get_id(self):
return self._token
def validate_password(self, password):
return bcrypt.check_password_hash(self._password, password)
@classmethod
def get(cls, _id):
"""
Get a user by their id or name from the database.
:param _id: the id (as an int) or name (as a str) of the user to get
:return: the user object in question or :class:`None` if no user
exists with the given id or name
"""
if type(_id) is int:
return cls.query.get(_id)
elif type(_id) is str or type(_id) is unicode:
return cls.query.filter(cls.name == _id).first()
else:
return None
@classmethod
def get_by_token(cls, token):
"""
Get a user by their token from the database.
:param token: The token of the user to get.
:return: the user object in question or :class:`None` if no
user exists with the token given
"""
return User.query.filter(User._token == token).first()
@classmethod
def all(cls):
"""
Get all users from the database.
:return: a list of all users in the database
"""
return cls.query.all()
class Test(db.Model):
__tablename__="test"
id=db.Column(db.Integer,primary_key=True)
name=db.Column(db.String(20))