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 User(db.Model):
id = db.Column(db.Integer, primary_key=True)
admin = db.Column(db.Boolean, default=False)
mail = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(128), nullable=False)
created = db.Column(db.DateTime, nullable=False, default=datetime.utcnow())
img = db.relationship('Userimg', secondary='user_imgs', backref=db.backref('users', lazy='dynamic'))
def __repr__(self):
return f"User('ID: {self.id}', 'Is Admin: {self.admin}', 'Mail: {self.mail}', 'Date Created: {self.created}')"
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 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 UserTagModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
def __init__(self, name):
self.name = name
def serialize(self):
return {
'id': self.id,
'name': self.name
}
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 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 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 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 Tag(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32, collation='NOCASE'))
slug = db.Column(db.String(140, collation='NOCASE'), unique=True)
def __init__(self, *args, **kwargs):
super(Tag, self).__init__(*args, **kwargs)
self.generate_slug()
def generate_slug(self):
if self.name:
self.slug = slugify(self.name)
def __repr__(self):
return f"Tag('{self.id}','{self.name}')"
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]
}
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 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 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 RecommendTypeModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200))
items = db.relationship('RecommendItemModel',
order_by="RecommendItemModel.orderid",
backref=db.backref('type', lazy='joined'),
lazy='dynamic')
def __init__(self, name):
self.name = name
def serialize(self):
return {
'id': self.id,
'name': self.name,
'items': url_for('.recommendItem', _external=True, typeid=self.id)
}
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 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 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 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 EmailModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
params = db.Column(db.Text)
sendDate = db.Column(db.DateTime)
expires = db.Column(db.DateTime)
to_user = db.Column(db.String(200))
def __init__(self, to_user=None, params=None, expires=None):
self.to_user = to_user
self.params = params
self.sendDate = datetime.datetime.now()
self.expires = expires
def serialize(self):
return {
# 'noteid': self.id,
# 'userid': self.owner.id,
# 'userName': self.owner.nickname,
# 'userImage': self.owner.getImage(),
# 'title': self.title,
# 'publishDate': self.publish_date.isoformat()
}
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 Product(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32, collation='NOCASE'))
slug = db.Column(db.String(140, collation='NOCASE'), unique=True)
description = db.Column(db.Text)
created = db.Column(db.DateTime, default=datetime.utcnow())
price = db.Column(db.Float)
img = db.relationship('Productimg', secondary='product_imgs', backref=db.backref('products', lazy='dynamic'))
tags = db.relationship('Tag', secondary='product_tags', backref=db.backref('products', lazy='dynamic'))
def __init__(self, *args, **kwargs):
super(Product, self).__init__(*args, **kwargs)
self.generate_slug()
def generate_slug(self):
if self.name:
self.slug = slugify(self.name)
def __repr__(self):
return f"Product('Name: {self.name}','Date Created: {self.created}','Description: {self.description}')"
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 LoginModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), unique=True)
password = db.Column(db.String(200))
lastLoginDate = db.Column(db.DateTime)
status = db.Column(db.Integer)
user_id = db.Column(db.Integer, unique=True)
def __init__(self, email, password, userid):
self.email = email
self.password = password
self.lastLoginDate = datetime.datetime.now()
self.status = account_status.disable
self.user_id = userid
def serialize(self):
return {
'id': self.id,
'email': self.email,
'lastLoginDate': self.lastLoginDate,
'status': self.status,
'user': url_for('.user', _external=True, userid=self.user_id)
}
class Userimg(db.Model):
id = db.Column(db.Integer, primary_key=True)
img = db.Column(db.String(20), nullable=False, default='default_user.jpg')
def __repr__(self):
return f"User('ID: {self.id}', 'IMG: {self.img}')"
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)
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)
publish_date = db.Column(db.DateTime)
ownerid = db.Column(db.Integer, db.ForeignKey('user_model.id'))
tags = db.relationship('WorkTagModel',
secondary=work_tags,
backref=db.backref('works', lazy='dynamic'))
# messages = db.relationship('NoteMessageModel', order_by="NoteMessageModel.publish_date",
# backref=db.backref('work', lazy='joined'), lazy='dynamic')
def __init__(self,
title=None,
thumbnail=None,
image=None,
file=None,
description=None,
copyright=None):
self.title = title
self.thumbnail = thumbnail
self.image = image
self.file = file
self.description = description
self.copyright = copyright
self.status = work_status.normal
self.publish_date = datetime.datetime.now()
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,
'publish_date':
self.publish_date.isoformat(),
'owner':
url_for('.userep', _external=True, userid=self.ownerid),
'tags':
url_for('.workTags', _external=True, workid=self.id)
}
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)
}
class Productimg(db.Model):
id = db.Column(db.Integer, primary_key=True)
img = db.Column(db.String(20), nullable=False, default='default_product.jpg')
