class WewFactor(db.Model):
__tablename__ = "wew_factor"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(1 - 0))
classes = {}
def __init__(self, id, name):
self.classes = []
self.id = id
self.name = name
def json(self):
"""Returns the models data converted to JSON"""
return {"classes": self.classes, "id": self.id, "name": self.name}
@staticmethod
def delete():
"""Empties the table specified in the model"""
db.session.execute("SET FOREIGN_KEY_CHECKS = 0; TRUNCATE TABLE wew_factor; SET FOREIGN_KEY_CHECKS = 1;")
db.session.commit()
def save(self):
"""Saves the object to the table specified in the model"""
db.session.add(self)
db.session.commit()
class TaxonLevel(db.Model):
__tablename__ = "taxon_level"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
def __init__(self, name):
self.name = name
def json(self):
"""Returns the models data converted to JSON"""
return {"id": self.id, "name": self.name}
@classmethod
def findTaxonLevelById(cls, id):
"""Returns the data of a specific taxon level chosen by id"""
return cls.query.filter_by(id = id).first()
@classmethod
def findAllTaxonLevels(cls):
"""Returns the data of all taxon levels"""
return cls.query.all()
def save(self):
"""Saves the object to the table specified in the model"""
db.session.add(self)
db.session.commit()
def delete(self):
"""Deletes the object from the table specified in the model"""
db.session.delete(self)
db.session.commit()
class Group(db.Model):
__tablename__ = "group"
Id = db.Column(db.Integer, primary_key=True)
GroupName = db.Column(db.String(50))
ShareObjectId = db.Column(db.Integer, db.ForeignKey("share.Id"))
GroupRead = db.Column(db.BOOLEAN)
GroupWrite = db.Column(db.BOOLEAN)
GroupCreate = db.Column(db.BOOLEAN)
GroupDelete = db.Column(db.BOOLEAN)
GroupDownload = db.Column(db.BOOLEAN)
CreateTime = db.Column(db.TIMESTAMP)
ShareObject = db.relationship('Share',
backref=db.backref('Groups', lazy='dynamic'),
lazy='select',
uselist=False)
Users = db.relationship('User',
secondary=groupusers,
backref=db.backref('Group', uselist=False))
UsersQuery = db.relationship('User', secondary=groupusers, lazy='dynamic')
def __init__(self, GroupName, GroupRead, GroupWrite, GroupCreate,
GroupDelete, GroupDownload):
self.GroupName = GroupName
self.GroupRead = GroupRead
self.GroupWrite = GroupWrite
self.GroupCreate = GroupCreate
self.GroupDelete = GroupDelete
self.GroupDownload = GroupDownload
# self.CreateTime='current_timestamp()'
def __repr__(self):
return '<Group %r>' % {'Id': self.Id, 'OwnerUserId': self.OwnerUserId}
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return '<Post {}>'.format(self.body)
class Subject(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200), unique=True)
def __init__(self, name):
self.name = name
def __repr__(self):
return "<Subject %r>" % self.name
class TaxonGroup(db.Model):
__tablename__ = "taxon_group"
id = db.Column(db.Integer, primary_key=True)
code = db.Column(db.String(8))
description = db.Column(db.String(100))
icon = db.Column(db.String(50))
def __init__(self, id, code, description, icon):
self.id = id
self.code = code
self.description = description
self.icon = icon
def json(self):
"""Returns the models data converted to JSON"""
return {
"id": self.id,
"code": self.code,
"description": self.description,
"icon": self.icon
}
@classmethod
def findTaxonGroupById(cls, id):
"""Returns the data of a specific taxon group chosen by id"""
return cls.query.filter_by(id=id).first()
@classmethod
def findAllTaxonGroups(cls):
"""Returns the data of all taxon groups"""
return cls.query.all()
def save(self):
"""Saves the object to the table specified in the model"""
db.session.add(self)
db.session.commit()
def delete(self):
"""Deletes the object from the table specified in the model"""
db.session.delete(self)
db.session.commit()
class Answer(db.Model):
id = db.Column(db.Integer, primary_key=True)
timestamp = db.Column(db.DateTime, unique=False)
question_id = db.Column(db.Integer, unique=False)
body = db.Column(db.String(), unique=False)
upvote_count = db.Column(db.Integer, unique=False)
def __init__(self, question_id, body):
self.timestamp = datetime.datetime.now()
self.question_id = question_id
self.body = body
self.upvote_count = 0
class Waterschap(db.Model):
__tablename__ = "waterschap"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
address = db.Column(db.String(255))
house_number = db.Column(db.String(4))
zip_code = db.Column(db.String(6))
location = db.Column(db.String(255))
phone_number = db.Column(db.String(20))
def __init__(self, id, name, address, house_number, zip_code, location,
phone_number):
self.id = id
self.name = name
self.address = address
self.house_number = house_number
self.zip_code = zip_code
self.location = location
self.phone_number = phone_number
def json(self):
"""Returns the models data converted to JSON"""
return {
"id": self.id,
"name": self.name,
"address": self.address,
"house_number": self.house_number,
"zip_code": self.zip_code,
"location": self.location,
"phone_number": self.phone_number
}
@classmethod
def findWaterschapById(cls, id):
"""Returns the data of a waterschap chosen by id"""
return cls.query.filter_by(id=id).first()
@classmethod
def findWaterschapByName(cls, name):
"""Returns the data of a waterschap chosen by name"""
return cls.query.filter_by(name=name).first()
@classmethod
def findAllWaterschappen(cls):
"""Returns the data of all waterschappen"""
return cls.query.all()
def save(self):
"""Saves the object to the table specified in the model"""
db.session.add(self)
db.session.commit()
def delete(self):
"""Deletes the object from the table specified in the model"""
db.session.delete(self)
db.session.commit()
class User(db.Model):
__tablename__ = "user"
Id = db.Column(db.Integer, primary_key=True)
NIPUserId = db.Column(db.BIGINT)
DomainId = db.Column(db.BIGINT, db.ForeignKey("domain.Id"))
DomainName = db.Column(db.VARCHAR(100))
Password = db.Column(db.CHAR(32))
SessionId = db.Column(db.String(50))
Email = db.Column(db.String(50))
NickName = db.Column(db.String(50))
type = db.Column(db.Integer)
CreateTime = db.Column(db.TIMESTAMP)
LeastTime = db.Column(db.DATETIME)
RealName = db.Column(db.VARCHAR(100))
Status = db.Column(db.Integer)
Identity = db.Column(db.VARCHAR(100))
CellPhone = db.Column(db.VARCHAR(100))
Level = db.Column(db.INT)
LastLoginTime = db.Column(db.DATETIME)
WeiXinOpenId = db.Column(db.VARCHAR(255))
Roles = db.relationship('Role',
secondary=userrole,
backref=db.backref('User', lazy='dynamic'))
DomainPermissionInvalidate = db.Column(db.INTEGER)
def __init__(self, NIPUserId, Email, NickName):
self.NIPUserId = NIPUserId
self.Email = Email
self.NickName = NickName
self.DomainPermissionInvalidate = 0
self.Password = None
self.Level = 0
self.WeiXinOpenId = ''
def __repr__(self):
return '<User %r>' % {'Id': self.Id, 'Email': self.Email}
class FileCache(db.Model):
__tablename__ = "fileCache"
Id = db.Column(db.BIGINT, primary_key=True)
ClientFileName = db.Column(db.String(255))
ServerFileName = db.Column(db.String(255))
Size = db.Column(db.BIGINT)
TotalSize = db.Column(db.BIGINT)
UserId = db.Column(db.BIGINT)
FileName = db.Column(db.String(255))
def __init__(self, ClientFileName, ServerFileName, FileSize, UserId,
FileName):
self.ClientFileName = ClientFileName
self.ServerFileName = ServerFileName
self.Size = 0
self.TotalSize = FileSize
self.UserId = UserId
self.FileName = FileName
def __repr__(self):
return '<FileCache %r>' % {
'Id': self.Id,
'ClientFileName': self.ClientFileName
}
class File(db.Model):
__tablename__ = "file"
Id = db.Column(db.Integer, primary_key=True)
Size = db.Column(db.Integer)
MD5 = db.Column(db.String(255)) #db.Column(db.BINARY(16))
RefCount = db.Column(db.Integer)
DelTime = db.Column(db.TIMESTAMP) # 删除到RefCount为0时的时间
Path = db.Column(db.String(255))
Ext = db.Column(db.String(255))
Status = db.Column(db.Integer)
CreateTime = db.Column(db.TIMESTAMP)
WatermarkFile = db.Column(db.String(255))
#转码后的视频文件如果有的话
VideoFile = db.Column(db.String(255))
#视频文件的FileCode
FileCode = db.Column(db.String(255))
HighFrequencyFile = db.Column(db.String(255))
LowFrequencyFile = db.Column(db.String(255))
TotalTime = db.Column(db.BIGINT)
Format = db.Column(db.VARCHAR(255))
BitRate = db.Column(db.FLOAT)
RatioWidth = db.Column(db.FLOAT)
RatioHeight = db.Column(db.FLOAT)
def __init__(self, Ext, Path, MD5, Size, RefCount, VideoUrl, Filecode):
self.Ext = Ext
self.Path = Path
self.MD5 = MD5
self.Size = Size
self.RefCount = RefCount
#self.CreateTime='current_timestamp()'
#self.DelTime = 'current_timestamp()'
#视频url
self.VideoFile = VideoUrl
self.FileCode = Filecode
def __repr__(self):
return '<File %r>' % {'Id': self.Id, 'MD5': self.MD5}
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(100))
password = db.Column(db.String(255))
name = db.Column(db.String(100))
session_token = db.Column(db.String(36))
expiration_date = db.Column(db.DateTime, default=datetime.datetime.now)
group_id = db.Column(db.Integer, db.ForeignKey("user_group.id"))
waterschap_id = db.Column(db.Integer, db.ForeignKey("waterschap.id"))
def __init__(self, id, email, password, name, session_token,
expiration_date, group_id, waterschap_id):
self.id = id
self.email = email
self.password = password
self.name = name
self.group_id = group_id
self.waterschap_id = waterschap_id
def json(self):
"""Returns the models data converted to JSON"""
return {
"id": self.id,
"email": self.email,
"password": self.password,
"name": self.name,
"groupId": self.group_id,
"waterschapId": self.waterschap_id
}
@classmethod
def findUserById(cls, id):
"""Returns the data of a user chosen by id"""
return cls.query.filter_by(id=id).first()
@classmethod
def findUserByEmail(cls, email):
"""Returns the data of a user chosen by email"""
return cls.query.filter_by(email=email).first()
@classmethod
def findAllUsers(cls):
"""Returns the data of all users"""
return cls.query.all()
def updateUser(self):
"""Saves the user data to an existing user"""
db.session.commit()
def addUser(self):
"""Saves the user data to an new user"""
db.session.add(self)
db.session.commit()
def removeUser(self):
"""Deletes the user from the table"""
db.session.delete(self)
db.session.commit()
def save(self):
"""Saves the object to the table specified in the model"""
db.session.add(self)
db.session.commit()
def delete(self):
"""Deletes the object from the table specified in the model"""
db.session.delete(self)
db.session.commit()
class Object(db.Model):
__tablename__ = "object"
Id = db.Column(db.Integer, primary_key=True)
OwnerUserId = db.Column(db.Integer)
FileId = db.Column(db.Integer, db.ForeignKey("file.Id"))
CreatorUserId = db.Column(db.Integer)
_Left_ = db.Column(db.Integer)
_Right_ = db.Column(db.Integer)
Name = db.Column(db.String(255))
Extend = db.Column(db.String(255))
Remark = db.Column(db.String(255))
Type = db.Column(db.String(255))
Status = db.Column(db.Integer)
ParentId = db.Column(db.Integer, db.ForeignKey("object.Id"))
Size = db.Column(db.Integer)
ModifyTime = db.Column(db.TIMESTAMP)
CreateTime = db.Column(db.TIMESTAMP)
Description = db.Column(db.String(1000))
Camera = db.Column(db.String(255))
Script = db.Column(db.String(255))
Category_1 = db.Column(db.INT)
Category_2 = db.Column(db.INT)
Tag = db.Column(db.VARCHAR(255))
BShare = db.Column(db.BOOLEAN)
ReferPrice = db.Column(db.FLOAT)
BasePrice = db.Column(db.FLOAT)
SchemePrice = db.Column(db.FLOAT)
ShotPrice = db.Column(db.FLOAT)
MusicPrice = db.Column(db.FLOAT)
ActorPrice = db.Column(db.FLOAT)
AEPrice = db.Column(db.FLOAT)
Price = db.Column(db.FLOAT) #竞价金额
File = db.relationship('File',
backref=db.backref('Objects', lazy='dynamic'),
lazy='joined')
Parent = db.relationship('Object',
backref=db.backref('Children', lazy='dynamic'),
remote_side=[Id],
uselist=False)
def __init__(self, Name, _Left_, _Right_, ParentId, OwnerUserId,
CreatorUserId, Size):
self.Name = Name
self._Left_ = _Left_
self._Right_ = _Right_
self.ParentId = ParentId
self.CreatorUserId = CreatorUserId
self.OwnerUserId = OwnerUserId
self.Size = Size
self.ReferPrice = 0
self.BShare = 0
self.BasePrice = 0
self.SchemePrice = 0
self.ShotPrice = 0
self.MusicPrice = 0
self.ActorPrice = 0
self.AEPrice = 0
self.Price = 0
# self.CreateTime='current_timestamp()'
def __repr__(self):
return '<Object %r>' % {'Name': self.Name}
class Taxon(db.Model):
__tablename__ = "taxon"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
group_id = db.Column(db.Integer, db.ForeignKey("taxon_group.id"))
level_id = db.Column(db.Integer, db.ForeignKey("taxon_level.id"))
parent_id = db.Column(db.Integer, db.ForeignKey("taxon.id"))
refer_id = db.Column(db.Integer, db.ForeignKey("taxon.id"))
hydrologische_verstoring = db.Column(db.Integer)
morfologische_verstoring = db.Column(db.Integer)
eutrofiering_belasting = db.Column(db.Integer)
def __init__(self, id, name, group_id, level_id, parent_id, refer_id,
hydrologische_verstoring, morfologische_verstoring,
eutrofiering_belasting):
self.id = id
self.name = name
self.group_id = group_id
self.level_id = level_id
self.parent_id = parent_id
self.refer_id = refer_id
self.hydrologische_verstoring = hydrologische_verstoring
self.morfologische_verstoring = morfologische_verstoring
self.eutrofiering_belasting = eutrofiering_belasting
def json(self):
"""Returns the models data converted to JSON"""
return {
"id": self.id,
"name": self.name,
"groupId": self.group_id,
"levelId": self.level_id,
"parentId": self.parent_id
}
def jsonSample(self):
"""Returns the models data converted to JSON"""
return {
"id": self.id,
"name": self.name,
"hydrologischeVerstoring": self.hydrologische_verstoring,
"morfologischeVerstoring": self.morfologische_verstoring,
"eutrofieringBelasting": self.eutrofiering_belasting
}
@classmethod
def findTaxonById(cls, id):
"""Returns the data of a specific taxon chosen by id"""
return cls.query.filter_by(id=id).first()
@classmethod
def findAllTaxons(cls):
"""Returns the data of all taxons"""
return cls.query.all()
@classmethod
def findTaxonByIds(cls, ids):
"""Returns the data of specific taxa chosen by ids"""
for id in ids:
return cls.query.filter_by(id=id[id])
pass
@classmethod
def findTaxonByName(cls, name):
"""Returns the data of specific taxa chosen by name"""
return cls.query.filter_by(name=name).first()
@classmethod
def findParentById(cls, parentId):
"""Returns the data of a specific parent taxon chosen by id"""
return cls.query.filter_by(id=parentId).first()
@classmethod
def findChildrenById(cls, id):
"""Returns the data of a specific child taxon chosen by id"""
return cls.query.filter_by(parent_id=id).all()
def save(self):
"""Saves the object to the table specified in the model"""
db.session.add(self)
db.session.commit()
def delete(self):
"""Deletes the object from the table specified in the model"""
db.session.delete(self)
db.session.commit()
class Location(db.Model):
__tablename__ = "location"
id = db.Column(db.Integer, primary_key=True)
code = db.Column(db.String(100))
description = db.Column(db.String(100))
x_coor = db.Column(db.Integer)
y_coor = db.Column(db.Integer)
waterschap_id = db.Column(db.Integer, db.ForeignKey("waterschap.id"))
watertype_id = db.Column(db.Integer, db.ForeignKey("watertype.id"))
watertype_krw_id = db.Column(db.Integer, db.ForeignKey("watertype.id"))
# TODO IN IPSEN5, AANPASSEN
latitude = 0
longitude = 0
def __init__(self, id, code, description, x_coor, y_coor, waterschap_id,
watertype_id, watertype_krw_id):
self.id = id
self.code = code
self.description = description
self.x_coor = x_coor
self.y_coor = y_coor
self.waterschap_id = waterschap_id
self.watertype_id = watertype_id
self.watertype_krw_id = watertype_krw_id
def json(self):
"""Returns the models data converted to JSON"""
return {
"id": self.id,
"code": self.code,
"description": self.description,
"xCoor": self.x_coor,
"yCoor": self.y_coor,
"latitude": self.latitude,
"longitude": self.longitude,
"waterschapId": self.waterschap_id,
"watertypeId": self.watertype_id,
"watertypeKrwId": self.watertype_krw_id
}
@classmethod
def findLocationById(cls, id):
"""Returns the data of a specific location chosen by id"""
return cls.query.filter_by(id=id).first()
@classmethod
def findLocationByIds(cls, ids):
"""Returns the data of specific locations chosen by ids"""
for id in ids:
return cls.query.filter_by(id=id[id])
@classmethod
def findLocationByCode(cls, code):
"""Returns the data of a specific location chosen by code"""
return cls.query.filter_by(code=code).first()
@classmethod
def findAllLocations(cls):
"""Returns the data of all locations"""
return cls.query.all()
def save(self):
"""Saves the object to the table specified in the model"""
db.session.add(self)
db.session.commit()
def delete(self):
"""Deletes the object from the table specified in the model"""
db.session.delete(self)
db.session.commit()
