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