class Comment(db.Model):
__tablename__ = "comments"
__table_args__ = {"extend_existing": True}
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text)
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
confirmed = db.Column(db.Boolean, default=True)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
post_id = db.Column(db.Integer, db.ForeignKey('posts.id'))
def save_to_db(self) -> "Comment":
db.session.add(self)
db.session.commit()
return self
def delete_from_db(self) -> None:
db.session.delete(self)
db.session.commit()
@classmethod
def find_by_id(cls, _id: int):
return cls.query.get_or_404(_id)
@classmethod
def find_all(cls) -> List["Comment"]:
return cls.query.all()
@classmethod
def find_all_confirmed(cls) -> List["Comment"]:
return cls.query.filter_by(confirmed=True)
class LocationGroup(Base):
__tablename__ = 'location_group'
name = db.Column(db.String(12), unique=True, nullable=False)
# Country is linked with LocationGroup via one to many relationship
country_id = db.Column(db.Integer,
db.ForeignKey('country.id'),
nullable=False)
panel_provider_id = db.Column(db.Integer,
db.ForeignKey('panel_provider.id'),
nullable=False)
def __init__(self, name, country_id, panel_provider_id):
self.name = name
self.country_id = country_id
self.panel_provider_id = panel_provider_id
def create(self):
db.session.add(self)
db.session.commit()
return self
def __repr__(self):
return '<LocationGroup: %r>' % self.name
class Batch(db.Model, CRUD):
__tablename__ = 'batches'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
agency_id = db.Column(db.Integer, db.ForeignKey('agencies.id'))
contact_id = db.Column(db.Integer, db.ForeignKey('contacts.id'))
# 样本类型: 粪便, 脑脊液,DNA,土壤,发酵品,其他
sample_type = db.Column(db.SmallInteger)
# 样品状态, 到样状态(干冰保存,冰袋冻存,室温,异常)
status = db.Column(db.SmallInteger)
# 状态特征: 固态粪便,液体脑积液微黄
character = db.Column(db.String(255))
deliver_time = db.Column(db.DateTime, server_default=db.func.now())
# deliver_time = db.Column(db.DateTime, default=datetime.now)
arrive_time = db.Column(db.DateTime, server_default=db.func.now())
express_num = db.Column(db.String(30), nullable=True)
# 入库时间
store_time = db.Column(db.DateTime, server_default=db.func.now())
# 存储位置及温度
position_id = db.Column(db.Integer, db.ForeignKey('positions.id'))
# 所属项目
subproject_id = db.Column(db.Integer, db.ForeignKey('subprojects.id'))
# 技术路线
roadmap_id = db.Column(db.Integer, db.ForeignKey('roadmaps.id'))
# 备注, 异常情况
remark = db.Column(db.Text, nullable=True)
samples = db.relationship('Sample', backref='batch', lazy='dynamic')
def __init__(self,
agency_id,
contact_id,
sample_type,
status,
character,
deliver_time,
arrive_time,
express_num,
store_time,
position_id,
subproject_id,
roadmap_id,
remark,
samples=[]):
self.agency_id = agency_id
self.contact_id = contact_id
self.sample_type = sample_type
self.status = status
self.character = character
# self.deliver_time = datetime_parser.parse(deliver_time).astimezone(
# tzutc()).replace(tzinfo=None)
# self.arrive_time = datetime_parser.parse(arrive_time).astimezone(
# tzutc()).replace(tzinfo=None)
self.deliver_time = deliver_time
self.arrive_time = arrive_time
self.express_num = express_num
self.store_time = store_time
self.position_id = position_id
self.subproject_id = subproject_id
self.roadmap_id = roadmap_id
self.remark = remark
self.samples = samples
class PostLikes(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
like_time = db.Column(db.DateTime, server_default=db.func.now())
def __init__(self, *args, **kwargs):
super(PostLikes, self).__init__(*args, **kwargs)
class Country(Base):
__tablename__ = 'country'
# Longest country code is a 6-length char "ITU callsign prefixes"
# Shortest are made of 2 chars
# https://en.wikipedia.org/wiki/Country_code
country_code = db.Column(db.String(6), unique=True, nullable=False)
panel_provider_id = db.Column(db.Integer,
db.ForeignKey('panel_provider.id'),
nullable=False)
# Country is linked with LocationGroup via one to many relationship
location_groups = db.relationship('LocationGroup',
backref='country',
lazy=True)
def __init__(self, country_code, panel_provider_id, location_groups=[]):
self.country_code = country_code
self.panel_provider_id = panel_provider_id
self.location_groups = location_groups
def create(self):
db.session.add(self)
db.session.commit()
return self
def __repr__(self):
return '<Country: %r>' % self.country_code
class FavoriteProducts(db.Model):
__tablename__ = 'favorite_products'
favorite_prod_id = db.Column(db.Integer,
primary_key=True,
autoincrement=True)
id = db.Column(db.String(36), nullable=False)
title = db.Column(db.String(255), nullable=False)
brand = db.Column(db.String(100), nullable=False)
image = db.Column(db.String(255), nullable=False)
price = db.Column(db.Float(), nullable=False)
reviewScore = db.Column(db.Float())
client_id = db.Column(db.Integer, db.ForeignKey('clients.id'))
def __init__(self,
id,
title,
brand,
image,
price,
reviewScore=None,
client_id=None):
self.id = id
self.title = title
self.brand = brand
self.image = image
self.price = price
self.reviewScore = reviewScore
self.client_id = client_id
def create(self):
db.session.add(self)
db.session.commit()
return self
class Customer(db.Model):
__tablename__ = 'customers'
id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
nullable=False)
name = db.Column(db.String(20), \
nullable = False)
surname = db.Column(db.String(20), \
nullable = False)
email = db.Column(db.String(80), unique=True, nullable=False)
photo = db.Column(db.String(500), nullable=True)
created = db.Column(db.DateTime, server_default=db.func.now())
creator_user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
last_modifier_user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
def __init__(self,
name,
surname,
email,
creator_user_id,
last_modifier_user_id,
photo=None):
self.name = name
self.surname = surname
self.photo = photo
self.email = email
self.creator_user_id = creator_user_id
self.last_modifier_user_id = last_modifier_user_id
def create(self):
db.session.add(self)
db.session.commit()
return self
class Sample(db.Model, CRUD):
__tablename__ = 'samples'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
batch_id = db.Column(db.Integer, db.ForeignKey('batches.id'))
client_id = db.Column(db.Integer, db.ForeignKey('clients.id'))
pmid = db.Column(db.String(20))
ori_num = db.Column(db.String(20))
# 与下面的amount配合,标识是重量还是体积
amount_type = db.Column(db.SmallInteger, nullable=True)
# 样品量,体积或重量(ml/g)
amount = db.Column(db.Float, nullable=True)
# 测序类型
sequence_method = db.Column(db.SmallInteger, nullable=True)
primer = db.Column(db.SmallInteger, nullable=True)
sequencer = db.Column(db.SmallInteger, nullable=True)
# 文库编号
library_id = db.Column(db.Integer, db.ForeignKey('libraries.id'))
# 备注, 异常情况
remark = db.Column(db.Text, nullable=True)
results = db.relationship('Result', backref='sample', lazy='dynamic')
def __init__(self,
batch_id,
client_id,
pmid,
ori_num,
amount_type,
amount,
sequence_method,
primer,
sequencer,
library_id,
remark,
results=[]):
self.batch_id = batch_id
self.client_id = client_id
self.pmid = pmid
self.ori_num = ori_num
self.amount_type = amount_type
self.amount = amount
self.sequence_method = sequence_method
self.primer = primer
self.sequencer = sequencer
self.library_id = library_id
self.remark = remark
self.results = results
class Subproject(db.Model, CRUD):
__tablename__ = 'subprojects'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(64))
project_id = db.Column(db.Integer, db.ForeignKey('projects.id'))
def __init__(self, name, project_id=None):
self.name = name
self.project_id = project_id
class Event(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True)
start_time = db.Column(db.DateTime)
end_time = db.Column(db.DateTime)
#Relationships 1:1
# track
track = db.Column(db.Integer, db.ForeignKey('track.id'))
class ImageFile(FileMixin, BaseMixin, db.Model):
"""
image file model
"""
__tablename__ = 'image_file'
video_id = db.Column(db.Integer, db.ForeignKey('video.id'))
def __repr__(self):
return '<ImageFile %r>' % self.id
class Contract(db.Model, CRUD):
__tablename__ = 'contracts'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
subproject_id = db.Column(db.Integer, db.ForeignKey('subprojects.id'))
name = db.Column(db.String(255))
sign_date = db.Column(db.DateTime)
start_date = db.Column(db.DateTime)
end_date = db.Column(db.DateTime)
region = db.Column(db.String(255))
agency_id = db.Column(db.Integer, db.ForeignKey('agencies.id'))
contact_id = db.Column(db.Integer, db.ForeignKey('contacts.id'))
product_type = db.Column(db.String(100))
sequence_area = db.Column(db.String(100))
sequence_type = db.Column(db.String(100))
data_size = db.Column(db.String(100))
def __init__(self,
name,
sign_date,
start_date,
end_date,
region,
product_type,
sequence_area,
sequence_type,
data_size,
subproject_id=None,
agency_id=None,
contact_id=None):
self.subproject_id = subproject_id
self.name = name
self.sign_date = sign_date
self.start_date = start_date
self.end_date = end_date
self.region = region
self.agency_id = agency_id
self.contact_id = contact_id
self.product_type = product_type
self.sequence_area = sequence_area
self.sequence_type = sequence_type
self.data_size = data_size
class Contact(db.Model, CRUD):
__tablename__ = 'contacts'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(20))
phone = db.Column(db.String(20))
email = db.Column(db.String(20))
agency_id = db.Column(db.Integer, db.ForeignKey('agencies.id'))
def __init__(self, name, phone, email, agency_id=None):
self.name = name
self.phone = phone
self.email = email
self.agency_id = agency_id
class Post(db.Model):
# id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), nullable=False)
body = db.Column(db.Text, nullable=False)
pub_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
category_id = db.Column(db.Integer,
db.ForeignKey('category.id'),
nullable=False)
category = db.relationship('Category',
backref=db.backref('posts', lazy=True))
def __repr__(self):
return '<Post %r>' % self.id
class TargetGroup(Base):
__tablename__ = 'target_group'
name = db.Column(db.String(24), unique=True, nullable=False)
external_id = db.Column(db.String(12), unique=True, nullable=False)
# TargetGroup model would have associations with it self
# via parent_id which would form a tree with multiple root nodes
parent_id = db.Column(db.Integer,
db.ForeignKey('target_group.id'),
nullable=True)
secret_code = db.Column(db.String(12), unique=True, nullable=False)
panel_provider_id = db.Column(db.Integer,
db.ForeignKey('panel_provider.id'),
nullable=False)
def __init__(self,
name,
external_id,
secret_code,
panel_provider_id,
parent_id=None):
self.name = name
self.external_id = external_id
self.parent_id = parent_id
self.secret_code = secret_code
self.panel_provider_id = panel_provider_id
def create(self):
db.session.add(self)
db.session.commit()
return self
def __repr__(self):
return '<TargetGroup: %r>' % self.name
class Feature(db.Model):
__tablename__ = 'features'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(100))
description = db.Column(db.String(250))
client_id = db.Column(db.Integer, db.ForeignKey('clients.id'))
priority = db.Column(db.Integer)
target_date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
product_area_id = db.Column(db.Integer, db.ForeignKey('productAreas.id'))
def __init__(self, title, description, client_id, priority, target_date,
product_area_id):
self.title = title
self.description = description
self.client_id = client_id
self.priority = priority
self.target_date = target_date
self.product_area_id = product_area_id
def create(self):
db.session.add(self)
db.session.commit()
return self
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(50))
photo = db.Column(db.String(20), nullable=True)
created = db.Column(db.DateTime, server_default=db.func.now())
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
likes = db.Column(db.Integer)
def __init__(self, *args, **kwargs):
super(Post, self).__init__(*args, **kwargs)
def create(self):
db.session.add(self)
db.session.commit()
return self
class Ref(db.Model, CRUD):
__tablename__ = 'refs'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
info_id = db.Column(db.Integer, db.ForeignKey('infos.id'))
status = db.Column(db.SmallInteger)
color = db.Column(db.SmallInteger)
img = db.Column(db.SmallInteger)
desc = db.Column(db.Text)
def __init__(self, info_id, status, color, img, desc):
self.info_id = info_id
self.status = status
self.color = color
self.img = img
self.desc = desc
class Book(db.Model):
__tablename__ = 'books'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(50))
year = db.Column(db.Integer)
author_id = db.Column(db.Integer, db.ForeignKey('authors.id'))
def __init__(self, title, year, author_id=None):
self.title = title
self.year = year
self.author_id = author_id
def create(self):
db.session.add(self)
db.session.commit()
return self
class Movie(db.Model):
__tablename__ = 'movies'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(50))
year = db.Column(db.Integer)
Director_id = db.Column(db.Integer, db.ForeignKey('directors.id'), nullable=False)
def __init__(self, title, year, director_id=None):
self.title = title
self.year = year
self.director_id = director_id
def create(self):
db.session.add(self)
db.session.commit()
return self
class Key(db.Model):
__tablename__ = 'keys'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128))
data = db.Column(db.String(1024))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
def __init__(self, name, data, user_id=None):
self.name = name
self.data = data
self.user_id = user_id
def create(self):
db.session.add(self)
db.session.commit()
return self
class Comments(db.Model):
__tablename__ = 'comments'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100))
time = db.Column(db.DateTime, server_default=db.func.now())
comment = db.Column(db.Text)
post_id = db.Column(db.Integer, db.ForeignKey('posts.id'))
def __init__(self, name, time, comment, post_id=None):
self.name = name
self.time = time
self.comment = comment
self.post_id = post_id
def create(self):
db.session.add(self)
db.session.commit()
return self
class VideoFile(FileMixin, BaseMixin, db.Model):
"""
video file model
"""
__tablename__ = 'video_file'
video_id = db.Column(db.Integer, db.ForeignKey('video.id'))
def __repr__(self):
return '<VidelFile %r>' % self.id
def delete(self):
"""
delete this entry and related file
"""
os.remove(self.file_path)
super(VideoFile, self).delete()
class Result(db.Model, CRUD):
__tablename__ = 'results'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# 报告产出日期
date = db.Column(db.DateTime, server_default=db.func.now())
sample_id = db.Column(db.Integer, db.ForeignKey('samples.id'))
# 结果状态: 未出具, 未审核, 已出具
status = db.Column(db.SmallInteger, default=0)
# 审核员: 按理说是角色为审核员的人
auditor = db.Column(db.String(10), nullable=True)
auditor_date = db.Column(db.DateTime, nullable=True)
content = db.Column(db.JSON)
def __init__(self, date, sample_id, status, auditor, content):
self.date = date
self.sample_id = sample_id
self.status = status
self.auditor = auditor
self.auditor_date = auditor_date
self.content = content
class Post(db.Model):
__tablename__ = "posts"
__table_args__ = {"extend_existing": True}
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
body = db.Column(db.Text)
title = db.Column(db.String(120))
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
# Relationships
tags = db.relationship(Tag, secondary=post_tag, backref=db.backref("posts_"))
author = db.relationship("User", backref="posts")
comments = db.relationship('Comment', backref='post', lazy='dynamic')
def save_to_db(self) -> "Post":
db.session.add(self)
db.session.commit()
return self
def add_to_session(self):
db.session.add(self)
def db_commit(self):
db.session.commit()
def delete_from_db(self) -> None:
db.session.delete(self)
db.session.commit()
@property
def comments_count(self):
return self.comments.filter_by(confirmed=True).count()
@classmethod
def find_all_confirmed(cls) -> List["Post"]:
return cls.query.filter_by(confirmed=True).order_by(cls.timestamp.desc())
class Confirmation(db.Model):
__tablename__ = "confirmations"
id = db.Column(db.String(50), primary_key=True)
expire_at = db.Column(db.Integer, nullable=False)
confirmed = db.Column(db.Boolean, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
def __init__(self, user_id: int, **kwargs):
super().__init__(**kwargs)
self.user_id = user_id
self.id = uuid4().hex
self.expire_at = int(time()) + CONFIRMATION_EXPIRATION_DELTA
self.confirmed = False
@classmethod
def find_by_id(cls, _id: str) -> "Confirmation":
return cls.query.filter_by(id=_id).first()
@property
def expired(self) -> bool:
return time() > self.expire_at
def force_to_expire(self) -> None:
if not self.expired:
self.expire_at = int(time())
self.save_to_db()
def save_to_db(self) -> None:
db.session.add(self)
db.session.commit()
def delete_from_db(self) -> None:
db.session.delete(self)
db.session.commit()
from api.utils.database import db
from marshmallow_sqlalchemy import ModelSchema
from marshmallow import fields
from .ref import Ref, RefSchema
from .category import Category, CategorySchema
from .crud import CRUD
category_infos = db.Table(
'category_infos', db.metadata,
db.Column('category_id', db.Integer, db.ForeignKey('categories.id')),
db.Column('info_id', db.Integer, db.ForeignKey('infos.id')))
class Info(db.Model, CRUD):
__tablename__ = 'infos'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
c_name = db.Column(db.String(255), nullable=True)
e_name = db.Column(db.String(255), nullable=True)
# TODO 类型信息,暂时还不确定是否和category有区别
desc = db.Column(db.String(255), nullable=True)
ref_min = db.Column(db.Float, nullable=True)
ref_max = db.Column(db.Float, nullable=True)
alias = db.Column(db.String(50), nullable=True)
refs = db.relationship('Ref', backref='info', lazy='dynamic')
categories = db.relationship('Category',
secondary=category_infos,
backref='infos')
def __init__(self,
c_name,
e_name,
class Token(db.Model):
__tablename__ = "tokens"
id = db.Column('id',
db.Integer,
autoincrement=True,
nullable=False,
primary_key=True)
code = db.Column('code',
db.VARCHAR(45),
nullable=False,
index=True,
unique=True)
expired_at = db.Column('expired_at', db.DateTime, nullable=False)
user_uuid = db.Column('user_uuid',
db.VARCHAR(36),
db.ForeignKey(name="fk_token_user1",
column="users.uuid",
onupdate='NO ACTION',
ondelete='SET NULL'),
nullable=True)
def __init__(self, user_uuid):
self.generate_token()
self.user_uuid = user_uuid
def generate_token(self):
expired_at = datetime.datetime.now() + datetime.timedelta(days=30)
expired_at.strftime("%Y-%m-%d %H:%M:%S")
self.code = secrets.token_hex(22)
self.expired_at = expired_at
return dict(code=self.code, expired_at=self.expired_at)
def check_validity(self):
date_token = self.expired_at.strftime("%Y-%m-%d %H:%M:%S")
today_date = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
return not date_token < today_date
def create(self):
db.session.add(self)
db.session.commit()
return self
def delete(self):
db.session.delete(self)
db.session.commit()
return self
def get_id(self):
return self.id
def get_code(self):
return self.code
def get_expired_at(self):
return self.expired_at
def get_user_uuid(self):
return self.user_uuid
def get_as_dict(self):
return dict(token=self.code,
user=(db.session.query(User).filter_by(
uuid=self.user_uuid).first()).get_as_dict(True))
@validates('id')
def check_id(self, key, value):
assert isinstance(value, int) is True, "id is invalid"
return value
@validates('code')
def check_code(self, key, value):
return value
@validates('expired_at')
def check_expired_at(self, key, value):
test = str(value)
regex = re.compile(
"""^(\d\d\d\d)-((0\d)|(1[012]))-(([012]\d)|(3[01])).(([01]\d)|(2[0123])):([0-5]\d)(:([0-5]\d)(\.\d+)?)?([zZ]|[\+\-]\d\d:\d\d)?$"""
)
assert re.match(regex, test) is not None, "time format is invalid"
return value
@validates('user_uuid')
def check_user_uuid(self, key, value):
uuid_regex = re.compile(
"""^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$"""
)
assert re.match(uuid_regex,
value) is not None, "user_uuid is not valid"
return value
class Video(db.Model):
__tablename__ = "videos"
uuid = db.Column('uuid', db.VARCHAR(36), primary_key=True, index=True, nullable=False)
name = db.Column('name', db.VARCHAR(45), nullable=True)
duration = db.Column('duration', db.Integer, nullable=False)
user_uuid = db.Column('user_uuid', db.VARCHAR(36), db.ForeignKey(name="fk_video_user",
column="users.uuid",
onupdate='NO ACTION',
ondelete='NO ACTION'))
source = db.Column('source', db.VARCHAR(512), nullable=False)
created_at = db.Column('created_at', db.DateTime, nullable=False)
views = db.Column('views', db.Integer, nullable=False)
enabled = db.Column('enabled', db.Boolean, nullable=False)
def __init__(self, name, duration, user_uuid, source, enabled):
self.uuid = str(uuid4())
self.name = name
self.duration = duration
self.user_uuid = user_uuid
self.source = source
self.created_at = datetime.datetime.now().strftime(("%Y-%m-%d %H:%M:%S"))
self.views = 0
self.enabled = enabled
def create(self):
db.session.add(self)
db.session.commit()
return self
def delete(self):
db.session.delete(self)
db.session.commit()
def update_name(self, name):
self.name = name
db.session.commit()
return self
def update_user(self, user):
self.user_uuid = user
db.session.commit()
return self
def get_as_dict(self):
format_list = []
formats = db.session.query(VideoFormat).filter_by(video_uuid=self.uuid).all()
for format in formats:
format_list = format.get_as_dict()
video = dict(
id=self.uuid,
name=self.name,
user=(db.session.query(User).filter_by(uuid=self.user_uuid).first()).get_as_dict(),
source=self.source,
created_at=self.created_at.strftime(("%Y-%m-%d %H:%M:%S")),
views=self.views,
enabled=self.enabled,
format=format_list
)
return video
@validates('uuid')
def check_id(self, key, value):
uuid_regex = re.compile("^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$")
assert re.match(uuid_regex, value) is not None, "video_uuid is not valid"
return value
@validates('name')
def check_name(self, key, value):
regex = re.compile("""^[\w!.?;,\/\-\_\%\*\#\é\è\=\-\&\s]{1,45}$""")
assert re.match(regex, value) is not None, "video name is invalid"
return value
@validates('duration')
def check_duration(self, key, value):
assert isinstance(value, int) is True, "duration is invalid"
return value
@validates('user_uuid')
def check_uuid(self, key, value):
uuid_regex = re.compile("^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$")
assert re.match(uuid_regex, value) is not None, "user_uuid is not valid"
return value
@validates('source')
def check_source(self, key, value):
# A vérifier en fonction du type de source généré par le code de flo
# regex = re.compile("^[(a-z)(A-Z)(0-9)]{5,45}$")
# assert re.match(regex, value) is not None, "source is invalid"
return value
@validates('created_at')
def check_created_at(self, key, value):
regex = re.compile("""^(\d\d\d\d)-((0\d)|(1[012]))-(([012]\d)|(3[01])).(([01]\d)|(2[0123])):([0-5]\d)(:([0-5]\d)(\.\d+)?)?([zZ]|[\+\-]\d\d:\d\d)?$""")
assert re.match(regex, str(value)) is not None, "time format is invalid"
return value
@validates('views')
def check_views(self, key, value):
assert isinstance(value, int) is True, "views is invalid"
return value
@validates('enabled')
def check_enabled(self, key, value):
assert isinstance(value, bool) is True, "enabled is invalid"
return value
#!/usr/bin/python
# -*- coding: utf-8 -*-
from api.models.model_location_group import LocationGroup
from api.utils.database import db
from marshmallow_sqlalchemy import ModelSchema
from marshmallow import fields
from api.models import Base
# Location is linked with LocationGroup via many to many relationship:
location_groups = db.Table(
'location_groups',
db.Column('location_id',
db.Integer,
db.ForeignKey('location.id'),
primary_key=True),
db.Column('location_group_id',
db.Integer,
db.ForeignKey('location_group.id'),
primary_key=True))
class Location(Base):
__tablename__ = 'location'
name = db.Column(db.String(12), unique=True, nullable=False)
external_id = db.Column(db.String(12), unique=True, nullable=False)
secret_code = db.Column(db.String(12), unique=True, nullable=False)
location_groups = db.relationship('LocationGroup',
secondary=location_groups,
