class NoteModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(500))
publishDate = db.Column(db.DateTime)
status = db.Column(db.Integer)
project_id = db.Column(db.Integer, db.ForeignKey('project_model.id'))
user_id = db.Column(db.Integer, db.ForeignKey('user_model.id'))
messages = db.relationship('NoteMessageModel',
order_by="NoteMessageModel.publishDate",
backref=db.backref('note', lazy='joined'),
lazy='dynamic')
def __init__(self, title):
self.title = title
self.publishDate = datetime.datetime.now()
self.status = note_status.normal
def __repr__(self):
return '<User %r>' % (self.title)
def serialize(self):
return {
'noteid': self.id,
'userid': self.user_id,
'userName': self.owner.nickname,
'userImage': self.owner.getImage(),
'title': self.title,
'publishDate': self.publishDate.isoformat()
}
class BidModel(db.Model):
bidding_price = db.Column(db.String(100))
bidding_description = db.Column(db.Text)
bidding_timespan = db.Column(db.String(100))
status = db.Column(db.Integer)
user_id = db.Column(db.Integer, db.ForeignKey('user_model.id'), primary_key=True)
task_id = db.Column(db.Integer, db.ForeignKey('task_model.id'), primary_key=True)
user = db.relationship('UserModel', lazy='joined')
task = db.relationship('TaskModel', lazy='joined')
def __init__(self, bidding_price=None, bidding_description=None, bidding_timespan=None):
self.bidding_price = bidding_price
self.bidding_description = bidding_description
self.bidding_timespan = bidding_timespan
self.status = bid_status.start
def serialize(self):
return {
'bidding_price': self.bidding_price,
'bidding_description': self.bidding_description,
'bidding_timespan': self.bidding_timespan,
'status': self.status,
'user_id': self.user_id,
'owner': url_for('.userep', _external=True, userid=self.user_id),
'task_id': self.task_id,
'task': url_for('.taskep', _external=True, taskid=self.task_id),
}
class VersionModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
file = db.Column(db.String(500))
image = db.Column(db.String(500))
title = db.Column(db.String(500))
description = db.Column(db.Text)
publish_date = db.Column(db.DateTime)
status = db.Column(db.Integer)
task_id = db.Column(db.Integer, db.ForeignKey('task_model.id'))
user_id = db.Column(db.Integer, db.ForeignKey('user_model.id'))
def __init__(self, title, description, image):
self.title = title
self.description = description
self.image = image
self.publish_date = datetime.datetime.now()
self.status = version_status.normal
def __repr__(self):
return '<User %r>' % (self.title)
def serialize(self):
return {
'id': self.id,
'image': getUploadFileUrl(file_type.version, self.user_id, self.image),
'title': self.title,
'description': self.description,
'publish_date': self.publish_date,
'status': self.status,
'user_id': self.user_id,
'task_id': self.task_id
}
class OrderModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
price = db.Column(db.Integer)
publishDate = db.Column(db.DateTime)
status = db.Column(db.Integer)
workid = db.Column(db.Integer, db.ForeignKey('work_model.id'))
buyerid = db.Column(db.Integer, db.ForeignKey('user_model.id'))
sellerid = db.Column(db.Integer, db.ForeignKey('user_model.id'))
def __init__(self, name, price=0):
self.name = name
self.price = price
self.publishDate = datetime.datetime.now()
self.status = order_status.notPay
def __repr__(self):
return '<User %r>' % (self.name)
def serialize(self):
return {
'id': self.id,
'name': self.name,
'price': self.price,
'publishDate': self.publishDate.isoformat(),
'status': self.status,
'workid': self.workid,
'buyerid': self.buyerid,
'sellerid': self.sellerid,
'buyer': url_for('.user', _external=True, userid=self.buyerid),
'seller': url_for('.user', _external=True, userid=self.sellerid)
}
class WorkMessageModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
message = db.Column(db.Text)
publishDate = db.Column(db.DateTime)
work_id = db.Column(db.Integer, db.ForeignKey('work_model.id'))
sender_id = db.Column(db.Integer, db.ForeignKey('user_model.id'))
buyer_id = db.Column(db.Integer, db.ForeignKey('user_model.id'))
seller_id = db.Column(db.Integer, db.ForeignKey('user_model.id'))
def __init__(self, message):
self.message = message
self.publishDate = datetime.datetime.now()
def __repr__(self):
return '<User %r>' % (self.message)
def serialize(self):
return {
'sender_id': self.sender.id,
'senderName': self.sender.nickname,
'senderImage': self.sender.getImage(),
'buyer_id': self.buyer.id,
'buyerName': self.buyer.nickname,
'buyerImage': self.buyer.getImage(),
'seller_id': self.seller.id,
'sellerName': self.seller.nickname,
'sellerImage': self.seller.getImage(),
'message': self.message,
'publishDate': self.publishDate,
'workid': self.work.id,
'workTitle': self.work.title
}
class ManualModel(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.String(100))
phone = db.Column(db.String(100))
location = db.Column(db.String(100))
authenticateDate = db.Column(db.DateTime)
userid = db.Column(db.Integer, db.ForeignKey('user_model.id'))
approvalStatus = db.Column(db.Integer)
def __init__(self, name, phone, location):
self.name = name
self.phone = phone
self.location = location
self.authenticateDate = datetime.datetime.now()
def serialize(self):
return {
'id': self.id,
'name': self.name,
'authenticateDate': self.authenticateDate,
'phone': self.phone,
'location': self.location,
'userid': self.userid,
'status': self.approvalStatus
}
class BankModel(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.String(200))
authenticateDate = db.Column(db.DateTime)
bankAccount = db.Column(db.String(100))
bankName = db.Column(db.String(500))
bankLocation = db.Column(db.String(200))
checkCode = db.Column(db.Integer)
userid = db.Column(db.Integer, db.ForeignKey('user_model.id'))
approvalStatus = db.Column(db.Integer)
def __init__(self, name, bankAccount, bankName, bankLocation):
self.name = name
self.authenticateDate = datetime.datetime.now()
self.bankAccount = bankAccount
self.bankName = bankName
self.bankLocation = bankLocation
def serialize(self):
return {
'id': self.id,
'name': self.name,
'authenticateDate': self.authenticateDate,
'bankAccount': self.bankAccount,
'bankName': self.bankName,
'bankLocation': self.bankLocation,
'userid': self.userid,
'status': self.approvalStatus,
'checkCode': self.checkCode
}
class CompanyAuthenticateModel(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.String(200))
authenticateDate = db.Column(db.DateTime)
businessScope = db.Column(db.Text)
licenseID = db.Column(db.String(500))
licenseImage = db.Column(db.String(500))
contactImage = db.Column(db.String(500))
verifyType = db.Column(db.Integer)
ownerid = db.Column(db.Integer, db.ForeignKey('user_model.id'))
approvalStatus = db.Column(db.Integer)
def __init__(self, name, businessScope, licenseID, licenseImage, contactImage, verifyType):
self.name = name
self.authenticateDate = datetime.datetime.now()
self.businessScope = businessScope
self.licenseID = licenseID
self.licenseImage = licenseImage
self.contactImage = contactImage
self.verifyType = verifyType
def serialize(self):
return {
'id': self.id,
'name': self.name,
'authenticateDate': self.authenticateDate,
'businessScope': self.businessScope,
'licenseID':self.licenseID,
'licenseImage': getUploadFileUrl(file_type.companyLience, self.ownerid, self.licenseImage),
'contactImage': getUploadFileUrl(file_type.companyContactCard, self.ownerid, self.contactImage),
'verifyType': self.verifyType,
'userid': self.ownerid,
'status': self.approvalStatus
}
class PrivateAuthenticateModel(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.String(200))
authenticateDate = db.Column(db.DateTime)
identityID = db.Column(db.String(50), nullable=False)
identityFrontImage = db.Column(db.String(100), nullable=False)
identityBackImage = db.Column(db.String(100), nullable=False)
ownerid = db.Column(db.Integer, db.ForeignKey('user_model.id'))
approvalStatus = db.Column(db.Integer)
def __init__(self, name, identityID, identityFrontImage, identityBackImage):
self.name = name
self.authenticateDate = datetime.datetime.now()
self.identityID = identityID
self.identityFrontImage = identityFrontImage
self.identityBackImage = identityBackImage
def serialize(self):
return {
'id': self.id,
'name': self.name,
'authenticateDate': self.authenticateDate,
'identityID': self.identityID,
'identityFrontImage': getUploadFileUrl(file_type.privateFront, self.ownerid, self.identityFrontImage),
'identityBackImage': getUploadFileUrl(file_type.privateBack, self.ownerid, self.identityBackImage),
'userid': self.ownerid,
'status': self.approvalStatus
}
class RecommendItemModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(200))
description = db.Column(db.Text)
image = db.Column(db.String(200))
url = db.Column(db.String(200))
orderid = db.Column(db.Integer)
typeid = db.Column(db.Integer, db.ForeignKey('recommend_type_model.id'))
def __init__(self, title, description, image, url, orderid):
self.title = title
self.description = description
self.image = image
self.url = url
self.orderid = orderid
def serialize(self):
return {
'id': self.id,
'title': self.title,
'description': self.description,
'image': getUploadFileUrl(file_type.recommend, self.typeid,
self.image),
'imageName': self.image,
'url': self.url,
'orderid': self.orderid
}
class ApprovalModel(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
authenticationType = db.Column(db.Integer)
authenticationID = db.Column(db.Integer)
approvalStatus = db.Column(db.Integer)
approvalDate = db.Column(db.DateTime)
userid = db.Column(db.Integer, db.ForeignKey('user_model.id'))
adminid = db.Column(db.Integer)
description = db.Column(db.Text)
def __init__(self, authenticationType, authenticationID, approvalStatus,
userid, adminid, description):
self.authenticationType = authenticationType
self.authenticationID = authenticationID
self.approvalStatus = approvalStatus
self.approvalDate = datetime.datetime.now()
self.userid = userid
self.adminid = adminid
self.description = description
def serialize(self):
return {
'id': self.id,
'type': self.authenticationType,
'authenID': self.authenticationID,
'approvalStatus': self.approvalStatus,
'approvalDate': self.approvalDate,
'userid': self.userid,
'user': url_for('.user', _external=True, userid=self.userid),
'adminid': self.adminid,
'admin': url_for('.user', _external=True, userid=self.adminid),
'description': self.description
}
class BidModel(db.Model):
price = db.Column(db.String(100))
description = db.Column(db.Text)
timespan = db.Column(db.String(100))
file = db.Column(db.String(200))
status = db.Column(db.Integer)
user_id = db.Column(db.Integer,
db.ForeignKey('user_model.id'),
primary_key=True)
project_id = db.Column(db.Integer,
db.ForeignKey('project_model.id'),
primary_key=True)
user = db.relationship('UserModel', lazy='joined')
project = db.relationship('ProjectModel', lazy='joined')
def __init__(self, price=None, description=None, timespan=None, file=None):
self.price = price
self.description = description
self.timespan = timespan
self.file = file
self.status = bid_status.start
def serialize(self):
return {
'price':
self.price,
'description':
self.description,
'timespan':
self.timespan,
'file':
getUploadFileUrl(file_type.bidFile, self.user_id, self.file),
'status':
self.status,
'userid':
self.user_id,
'user':
url_for('.user', _external=True, userid=self.user_id),
'projectid':
self.project_id,
'project':
url_for('.project', _external=True, projectid=self.project_id),
}
class WorkModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(200))
thumbnail = db.Column(db.String(200))
image = db.Column(db.String(200))
file = db.Column(db.String(200))
description = db.Column(db.Text)
copyright = db.Column(db.Integer)
status = db.Column(db.Integer)
publishDate = db.Column(db.DateTime)
price = db.Column(db.Integer)
ownerid = db.Column(db.Integer, db.ForeignKey('user_model.id'))
orders = db.relationship('OrderModel', backref=db.backref(
'work', lazy='joined'), lazy='dynamic')
tags = db.relationship('WorkTagModel', secondary=work_tags,
backref=db.backref('works', lazy='dynamic'))
pics = db.relationship('WorkPicModel', backref=db.backref(
'work', lazy='joined'), lazy='dynamic')
messages = db.relationship('WorkMessageModel', order_by="WorkMessageModel.publishDate",
backref=db.backref('work', lazy='joined'), lazy='dynamic')
def __init__(self, title=None, thumbnail=None, image=None, file=None, description=None, copyright=None, price=0):
self.title = title
self.thumbnail = thumbnail
self.image = image
self.file = file
self.description = description
self.copyright = copyright
self.status = work_status.normal
self.publishDate = datetime.datetime.now()
self.price = price
def __repr__(self):
return '<User %r>' % (self.title)
def serialize(self):
return {
'userid': self.ownerid,
'workid': self.id,
'title': self.title,
'thumbnail': getUploadFileUrl(file_type.workThumbnail, self.ownerid, self.thumbnail),
'image': getUploadFileUrl(file_type.work, self.ownerid, self.image),
'file': getUploadFileUrl(file_type.workFile, self.ownerid, self.file),
'description': self.description,
'copyright': self.copyright,
'status': self.status,
'publishDate': self.publishDate.isoformat(),
'owner': url_for('.user', _external=True, userid=self.ownerid),
'tags': url_for('.workTags', _external=True, workid=self.id),
'price': self.price
}
class WorkPicModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
image = db.Column(db.String(200))
num = db.Column(db.Integer)
workid = db.Column(db.Integer, db.ForeignKey('work_model.id'))
ownerid = db.Column(db.Integer, db.ForeignKey('user_model.id'))
def __init__(self, image, num):
self.image = image
self.num = num
def __repr__(self):
return '<User %r>' % (self.num)
def serialize(self):
return {
'workid': self.workid,
'ownerid': self.ownerid,
'image': getUploadFileUrl(file_type.workPic, self.ownerid, self.image),
'num': self.num
}
class KindModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
status = db.Column(db.Integer)
parent_id = db.Column(db.Integer, db.ForeignKey('kind_model.id'))
parent = db.relationship('KindModel', remote_side=[id],
backref=db.backref('kids', lazy='dynamic'), lazy='joined')
def __init__(self, name):
self.name = name
self.status = kind_status.normal
class TaskModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
timespan = db.Column(db.String(200))
requirements = db.Column(db.Text)
bonus = db.Column(db.Integer)
description = db.Column(db.Text)
publishDate = db.Column(db.DateTime)
bidderQualifiRequire = db.Column(db.String(100))
bidderLocationRequire = db.Column(db.String(100))
status = db.Column(db.Integer)
receipt = db.Column(db.Boolean)
receiptDes = db.Column(db.String(500))
winnerid = db.Column(db.Integer, db.ForeignKey('user_model.id'))
projectid = db.Column(db.Integer, db.ForeignKey('project_model.id'))
kinds = db.relationship('KindModel', secondary=task_kinds, backref=db.backref('tasks', lazy='dynamic'))
versions = db.relationship('VersionModel', backref=db.backref('task', lazy='joined'), lazy='dynamic')
notes = db.relationship('NoteModel', backref=db.backref('task', lazy='joined'), lazy='dynamic')
bidders = db.relationship('BidModel', lazy='dynamic')
def __init__(self, name, timespan=None, requirements=None, bonus=0, description=None,
bidderQualifiRequire=None, bidderLocationRequire=None, receipt=False, receiptDes=None):
self.name = name
self.timespan = timespan
self.requirements = requirements
self.bonus = bonus
self.description = description
self.publishDate = datetime.datetime.now()
self.bidderQualifiRequire = bidderQualifiRequire
self.bidderLocationRequire = bidderLocationRequire
self.status = task_status.disable
self.receipt = receipt
self.receiptDes = receiptDes
def __repr__(self):
return '<User %r>' % (self.name)
class NoteMessageModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
message = db.Column(db.Text)
publishDate = db.Column(db.DateTime)
note_id = db.Column(db.Integer, db.ForeignKey('note_model.id'))
user_id = db.Column(db.Integer, db.ForeignKey('user_model.id'))
def __init__(self, message):
self.message = message
self.publishDate = datetime.datetime.now()
def __repr__(self):
return '<User %r>' % (self.message)
def serialize(self):
return {
'userid': self.owner.id,
'userName': self.owner.nickname,
'userImage': self.owner.getImage(),
'message': self.message,
'publishDate': self.publishDate
}
class ProjectModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(500))
status = db.Column(db.Integer)
description = db.Column(db.Text)
publish_date = db.Column(db.DateTime)
ownerid = db.Column(db.Integer, db.ForeignKey('user_model.id'))
tasks = db.relationship('TaskModel',
backref=db.backref('project', lazy='joined'),
lazy='dynamic')
def __init__(self, projectName, description=None):
self.name = projectName
self.status = project_status.disable
self.description = description
self.publish_date = datetime.datetime.now()
def __repr__(self):
return '<User %r>' % (self.name)
def serialize(self):
return {
'ownerid':
self.ownerid,
'projectId':
self.id,
'projectName':
self.name,
'description':
self.description,
'publish_date':
self.publish_date.isoformat(),
'status':
self.status,
'tasks_url':
url_for('.getTasksByProjectID', _external=True, projectid=self.id),
'owner':
url_for('.userep', _external=True, userid=self.ownerid)
}
class CategoryModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
status = db.Column(db.Integer)
parent_id = db.Column(db.Integer, db.ForeignKey('category_model.id'))
parent = db.relationship('CategoryModel',
remote_side=[id],
backref=db.backref('kids', lazy='dynamic'),
lazy='joined')
def __init__(self, name):
self.name = name
self.status = category_status.normal
def serialize(self):
return {
'id': self.id,
'name': self.name,
'parentid': self.parent_id,
'status': self.status
}
class ProjectModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
timespan = db.Column(db.String(200))
requirements = db.Column(db.Text)
bonus = db.Column(db.Integer)
description = db.Column(db.Text)
publishDate = db.Column(db.DateTime)
bidderQualifiRequire = db.Column(db.String(100))
bidderLocationRequire = db.Column(db.String(100))
status = db.Column(db.Integer)
receipt = db.Column(db.Boolean)
receiptDes = db.Column(db.String(500))
ownerid = db.Column(db.Integer, db.ForeignKey('user_model.id'))
winnerid = db.Column(db.Integer, db.ForeignKey('user_model.id'))
categorys = db.relationship('CategoryModel',
secondary=project_categorys,
backref=db.backref('projects', lazy='dynamic'))
versions = db.relationship('VersionModel',
backref=db.backref('project', lazy='joined'),
lazy='dynamic')
notes = db.relationship('NoteModel',
backref=db.backref('project', lazy='joined'),
lazy='dynamic')
bidders = db.relationship('BidModel', lazy='dynamic')
def __init__(self,
name,
timespan=None,
requirements=None,
bonus=0,
description=None,
bidderQualifiRequire=None,
bidderLocationRequire=None,
receipt=False,
receiptDes=None):
self.name = name
self.timespan = timespan
self.requirements = requirements
self.bonus = bonus
self.description = description
self.publishDate = datetime.datetime.now()
self.bidderQualifiRequire = bidderQualifiRequire
self.bidderLocationRequire = bidderLocationRequire
self.status = project_status.disable
self.receipt = receipt
self.receiptDes = receiptDes
def __repr__(self):
return '<User %r>' % (self.name)
def serialize(self):
return {
'id':
self.id,
'name':
self.name,
'timespan':
self.timespan,
'requirements':
self.requirements,
'bonus':
self.bonus,
'description':
self.description,
'publishDate':
self.publishDate.isoformat(),
'bidderQualifiRequire':
self.bidderQualifiRequire,
'bidderLocationRequire':
self.bidderLocationRequire,
'status':
self.status,
'receipt':
self.receipt,
'receiptDes':
self.receiptDes,
'owner':
url_for('.user', _external=True, userid=self.ownerid),
'winner':
url_for('.user', _external=True, userid=self.winnerid)
if self.winnerid else '',
'versions':
url_for('.projectVersions', _external=True, projectid=self.id),
'notes':
url_for('.projectNotes', _external=True, projectid=self.id),
'bids':
url_for('.projectBids', _external=True, projectid=self.id),
'bidCount':
url_for('.projectCount', _external=True, projectid=self.id),
'categorys':
url_for('.projectCategorys', _external=True, projectid=self.id)
}
from myapi import db
from enum import category_status
user_categorys = db.Table(
'user_categorys',
db.Column('category_id',
db.Integer,
db.ForeignKey('category_model.id'),
primary_key=True),
db.Column('user_id',
db.Integer,
db.ForeignKey('user_model.id'),
primary_key=True))
project_categorys = db.Table(
'project_categorys',
db.Column('category_id',
db.Integer,
db.ForeignKey('category_model.id'),
primary_key=True),
db.Column('project_id',
db.Integer,
db.ForeignKey('project_model.id'),
primary_key=True))
class CategoryModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
status = db.Column(db.Integer)
fields = ('id', 'name', 'slug', 'description', 'created', 'price', 'img', 'tags')
# Product images
class Productimg(db.Model):
id = db.Column(db.Integer, primary_key=True)
img = db.Column(db.String(20), nullable=False, default='default_product.jpg')
# Product Img Schema
class ProductImgSchema(ma.Schema):
class Meta:
fields = ('id', 'product_id', 'img')
# Many to Many (Product - img)
product_imgs = db.Table('product_imgs',
db.Column('product_id', db.Integer, db.ForeignKey('product.id')),
db.Column('img_id', db.Integer, db.ForeignKey('productimg.id'))
)
# Many to Many (Product - Tag )
product_tags = db.Table('product_tags',
db.Column('product_id', db.Integer, db.ForeignKey('product.id')),
db.Column('tag_id', db.Integer, db.ForeignKey('tag.id'))
)
########## TAG MODELS ##########
# Tag model
class Tag(db.Model):
id = db.Column(db.Integer, primary_key=True)
from myapi import db
from myapi.model.enum import tag_status
user_tags = db.Table(
'user_tags',
db.Column('tag_id', db.Integer, db.ForeignKey('user_tag_model.id')),
db.Column('user_id', db.Integer, db.ForeignKey('user_model.id')))
work_tags = db.Table(
'work_tags',
db.Column('tag_id', db.Integer, db.ForeignKey('work_tag_model.id')),
db.Column('work_id', db.Integer, db.ForeignKey('work_model.id')))
class UserTagModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
status = db.Column(db.Integer)
def __init__(self, name):
self.name = name
self.status = tag_status.normal
def serialize(self):
return {
'id': self.id,
'name': self.name,
'status': self.status,
'count': self.users.count(),
'users': [u.serialize() for u in self.users]
}
from myapi import db
from enum import kind_status
# project_kinds = db.Table('project_kinds',
# db.Column('kind_id', db.Integer, db.ForeignKey('kind_model.id'), primary_key=True),
# db.Column('project_id', db.Integer, db.ForeignKey('project_model.id'), primary_key=True)
# )
task_kinds = db.Table('task_kinds',
db.Column('kind_id', db.Integer, db.ForeignKey('kind_model.id'), primary_key=True),
db.Column('task_id', db.Integer, db.ForeignKey('task_model.id'), primary_key=True)
)
class KindModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
status = db.Column(db.Integer)
parent_id = db.Column(db.Integer, db.ForeignKey('kind_model.id'))
parent = db.relationship('KindModel', remote_side=[id],
backref=db.backref('kids', lazy='dynamic'), lazy='joined')
def __init__(self, name):
self.name = name
self.status = kind_status.normal
