class Contract(db.Model):
__tablename__ = "contract"
Id = db.Column(db.BIGINT, primary_key=True)
RequirementId = db.Column(db.BIGINT, db.ForeignKey('requirement.Id'))
Version = db.Column(db.BIGINT)
Title = db.Column(db.VARCHAR(255))
Detail = db.Column(db.TEXT)
ServiceUserId = db.Column(db.BIGINT, db.ForeignKey('user.Id'))
CustomerUserId = db.Column(db.BIGINT, db.ForeignKey('user.Id'))
Status = db.Column(db.BIGINT)
Amount = db.Column(db.FLOAT)
CreateTime = db.Column(db.TIMESTAMP)
PayState = db.Column(db.INTEGER)
Scheme = db.Column(db.TEXT)
Script = db.Column(db.TEXT)
DepositPercent = db.Column(db.FLOAT)
Procedure = db.Column(db.VARCHAR(20)) # active, applyAbort, abort
Requirement = db.relation('Requirement', backref=db.backref('Contract', lazy='joined'),
foreign_keys='Contract.RequirementId', lazy='joined')
ServiceUser = db.relation('User', backref=db.backref('AsServiceContract', lazy='dynamic'),
foreign_keys='Contract.ServiceUserId', lazy='joined')
CustomerUser = db.relation('User', backref=db.backref('AsCustomerContract', lazy='dynamic'),
foreign_keys='Contract.CustomerUserId', lazy='joined')
# ContractSegmentDynamic = db.relation('ContractSegment', lazy='dynamic')
def __init__(self):
self.DepositPercent = 50.0
self.Procedure = 'active'
class Share(db.Model):
__tablename__ = "share"
Id = db.Column(db.Integer, primary_key=True)
ObjectId = db.Column(db.Integer, db.ForeignKey("object.Id"))
CreatorUserId = db.Column(db.Integer, db.ForeignKey("user.Id"))
Name = db.Column(db.VARCHAR(255))
CreateTime = db.Column(db.TIMESTAMP)
Users = db.relationship("ShareUser",
backref=db.backref("Share", uselist=False),
lazy="dynamic",
foreign_keys="ShareUser.ShareObjectId")
CreatorUser = db.relationship("User",
backref=db.backref("Shares", lazy="dynamic"),
uselist=False,
foreign_keys="Share.CreatorUserId")
Object = db.relationship("Object",
uselist=False,
backref=db.backref("Shares"))
UsersCache = db.relationship("ShareUserCache",
backref=db.backref("Share", uselist=False),
lazy="dynamic",
foreign_keys="ShareUserCache.ShareObjectId")
def __init__(self, Name, CreatorUserId, ObjectId):
self.Name = Name
self.CreatorUserId = CreatorUserId
self.ObjectId = ObjectId
# self.CreateTime='current_timestamp()'
def __repr__(self):
return '<Share %r>' % {
'Id': self.Id,
'CreatorUserId': self.CreatorUserId
}
class ShareUserCache(db.Model):
__tablename__ = "shareusercache"
Id = db.Column(db.Integer, primary_key=True)
ShareObjectId = db.Column(db.Integer, db.ForeignKey("share.Id"))
UserId = db.Column(db.Integer, db.ForeignKey("user.Id"))
UserRead = db.Column(db.BOOLEAN)
UserWrite = db.Column(db.BOOLEAN)
UserCreate = db.Column(db.BOOLEAN)
UserDelete = db.Column(db.BOOLEAN)
UserDownload = db.Column(db.BOOLEAN)
CreateTime = db.Column(db.TIMESTAMP)
User = db.relationship('User',
lazy='joined',
backref=db.backref('ShareCache', lazy='dynamic'))
ShareObject = db.relationship('Share',
uselist=False,
backref=db.backref('ShareUserCache',
lazy='dynamic'))
def __init__(self, UserId, UserRead, UserWrite, UserCreate, UserDelete,
UserDownload):
self.UserId = UserId
self.UserRead = UserRead
self.UserWrite = UserWrite
self.UserCreate = UserCreate
self.UserDelete = UserDelete
self.UserDownload = UserDownload
# self.CreateTime='current_timestamp()'
def __repr__(self):
return '<Domain %r>' % {'Id': self.Id, 'UserId': self.UserId}
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 ProjectSegment(db.Model):
__tablename__ = "projectsegment"
Id = db.Column(db.BIGINT, primary_key=True)
ProjectId = db.Column(db.BIGINT, db.ForeignKey('project.Id'))
ContractSegmentId = db.Column(db.BIGINT,
db.ForeignKey('contractsegment.Id'))
PrincipalUserId = db.Column(db.BIGINT, db.ForeignKey('user.Id'))
Segment = db.Column(db.BIGINT)
Deadline = db.Column(db.DATETIME)
Remark = db.Column(db.VARCHAR(2000))
ApplyUserId = db.Column(db.BIGINT, db.ForeignKey('user.Id'))
ApplyTime = db.Column(db.DATETIME)
ApplyRemark = db.Column(db.VARCHAR(2000))
ConfirmUserId = db.Column(db.BIGINT, db.ForeignKey('user.Id'))
ConfirmTime = db.Column(db.DATETIME)
ConfirmRemark = db.Column(db.VARCHAR(2000))
Status = db.Column(db.BIGINT)
CreateTime = db.Column(db.TIMESTAMP)
ContractSegment = db.relation('ContractSegment',
backref=db.backref('ProjectSegment',
lazy='dynamic'))
Project = db.relation('Project',
backref=db.backref('ProjectSegment', lazy='joined'))
ApplyUser = db.relation('User',
foreign_keys='ProjectSegment.ApplyUserId',
lazy='joined')
ConfirmUser = db.relation('User',
foreign_keys='ProjectSegment.ConfirmUserId',
lazy='joined')
class ProjectEventLog(db.Model):
__tablename__ = "projecteventlog"
Id = db.Column(db.BIGINT, primary_key=True)
ProjectId = db.Column(db.BIGINT, db.ForeignKey('project.Id'))
UserId = db.Column(db.BIGINT, db.ForeignKey('user.Id'))
Action = db.Column(db.BIGINT)
Segment = db.Column(db.BIGINT)
Detail = db.Column(db.TEXT)
CreateTime = db.Column(db.TIMESTAMP)
Project = db.relation('Project', backref=db.backref('ProjectEventLog', lazy='dynamic'))
ApplyUser = db.relation('User', backref=db.backref('ProjectEventLog', lazy='dynamic'))
class RequirementReply(db.Model):
__tablename__ = "requirementreply"
Id = db.Column(db.BIGINT, primary_key=True)
RequirementId = db.Column(db.BIGINT, db.ForeignKey('requirement.Id'))
PublisherId = db.Column(db.BIGINT, db.ForeignKey('user.Id'))
Reply = db.Column(db.Text)
Status = db.Column(db.BIGINT)
CreateTime = db.Column(db.TIMESTAMP)
ReplyGroup = db.Column(db.BIGINT)
Requirement = db.relation('Requirement', backref=db.backref('RequirementReply', lazy='dynamic'))
Publisher = db.relation('User', backref=db.backref('RequirementReply', lazy='dynamic'))
class ContractAttachment(db.Model):
__tablename__ = "contractattachment"
Id = db.Column(db.BIGINT, primary_key=True)
ContractId = db.Column(db.BIGINT, db.ForeignKey('contract.Id'))
ProviderUserId = db.Column(db.BIGINT, db.ForeignKey('user.Id'))
ObjectId = db.Column(db.BIGINT, db.ForeignKey('object.Id'))
CreateTime = db.Column(db.TIMESTAMP)
Type = db.Column(db.INT)
Status = db.Column(db.INT)
Contract = db.relation('Contract', backref=db.backref('ContractAttachment', lazy='dynamic'))
ProviderUser = db.relation('User', backref=db.backref('ContractAttachment', lazy='dynamic'))
Object = db.relation('Object', lazy='joined')
class ContractEventLog(db.Model):
__tablename__ = "contracteventlog"
Id = db.Column(db.BIGINT, primary_key=True)
ContractId = db.Column(db.BIGINT, db.ForeignKey('contract.Id'))
UserId = db.Column(db.BIGINT, db.ForeignKey('user.Id'))
Action = db.Column(db.BIGINT)
Segment = db.Column(db.BIGINT)
Detail = db.Column(db.TEXT)
CreateTime = db.Column(db.TIMESTAMP)
Contract = db.relation('Contract', backref=db.backref('ContractEventLog', lazy='dynamic'))
User = db.relation('User', backref=db.backref('ContractEventLog', lazy='dynamic'))
def __init__(self, con_id, user_id, action, segment, detail):
self.ContractId = con_id
self.UserId = user_id
self.Action = action
self.Segment = segment
self.Detail = detail
class RequirementSegment(db.Model):
__tablename__ = 'requirement_segment'
Id = db.Column(db.BIGINT, primary_key=True)
RequirementId = db.Column(db.BIGINT, db.ForeignKey('requirement.Id'))
SegmentId = db.Column(db.INT, db.ForeignKey('segment.Id'))
Segment = db.relation('Segment', lazy='joined')
Requirement = db.relation('Requirement', backref=db.backref('Segments', lazy='joined'), lazy='joined')
def __init__(self, req_id, seg_id):
self.RequirementId = req_id
self.SegmentId = seg_id
class RequirementFollower(db.Model):
__tablename__ = 'requirement_follower'
Id = db.Column(db.BIGINT, primary_key=True)
RequirementId = db.Column(db.BIGINT, db.ForeignKey('requirement.Id'))
FollowerProducerId = db.Column(db.BIGINT, db.ForeignKey('user.Id'))
Scheme = db.Column(db.TEXT)
Script = db.Column(db.TEXT)
CreateTime = db.Column(db.TIMESTAMP)
FollowerDomainId = db.Column(db.BIGINT)
IsDeny = db.Column(db.BOOLEAN)
Long = db.Column(db.VARCHAR(100))
Format = db.Column(db.VARCHAR(100))
Subtitle = db.Column(db.VARCHAR(2048))
Voice = db.Column(db.VARCHAR(2048))
Gbm = db.Column(db.VARCHAR(2048))
Amount = db.Column(db.FLOAT)
DepositPercent = db.Column(db.FLOAT)
Remark = db.Column(db.TEXT)
Status = db.Column(db.INT) # 是否申请方案确认，0为未申请，1为申请中
BasePrice = db.Column(db.FLOAT)
SchemePrice = db.Column(db.FLOAT)
ShotPrice = db.Column(db.FLOAT)
ActorPrice = db.Column(db.FLOAT)
MusicPrice = db.Column(db.FLOAT)
AEPrice = db.Column(db.FLOAT)
Follower = db.relation(
'User',
foreign_keys='RequirementFollower.FollowerProducerId',
lazy='joined')
Requirement = db.relation('Requirement',
backref=db.backref('RequirementFollower',
lazy='joined'))
def __init__(self, req_id, followerproducer_id, domain_id):
self.RequirementId = req_id
self.FollowerProducerId = followerproducer_id
self.FollowerDomainId = domain_id
self.IsDeny = 0
self.Long = ''
self.Format = ''
self.Subtitle = ''
self.Voice = ''
self.Gbm = ''
self.Amount = 0
self.Script = ''
self.Remark = ''
self.DepositPercent = 50
self.Status = 0
self.BasePrice = 0
self.SchemePrice = 0
self.ShotPrice = 0
self.ActorPrice = 0
self.MusicPrice = 0
self.AEPrice = 0
class RequirementAttachment(db.Model):
__tablename__ = "requirementattachment"
Id = db.Column(db.BIGINT, primary_key=True)
RequirementId = db.Column(db.BIGINT, db.ForeignKey('requirement.Id'))
OperateUserId = db.Column(db.BIGINT, db.ForeignKey('user.Id'))
ObjectId = db.Column(db.BIGINT, db.ForeignKey('object.Id'))
CreateTime = db.Column(db.TIMESTAMP)
Description = db.Column(db.VARCHAR(255))
Requirement = db.relation('Requirement', backref=db.backref('RequirementAttachment', lazy='dynamic'))
Object = db.relation('Object', lazy='joined')
OperateUser = db.relation('User', lazy='joined')
class FollowerAttachment(db.Model):
__tablename__ = 'followerattachment'
Id = db.Column(db.BIGINT, primary_key=True)
FollowerId = db.Column(db.BIGINT, db.ForeignKey('requirement_follower.Id'))
ObjectId = db.Column(db.BIGINT, db.ForeignKey('object.Id'))
CreateTime = db.Column(db.TIMESTAMP)
Follower = db.relation('RequirementFollower', backref=db.backref('FollowerAttachment', lazy='joined'))
Object = db.relation('Object', lazy='joined')
def __init__(self, follower_id, object_id):
self.FollowerId = follower_id
self.ObjectId = object_id
self.CreateTime = datetime.datetime.now()
class ContractOrder(db.Model):
__tablename__ = "contract_order"
Id = db.Column(db.BIGINT, primary_key=True)
ContractId = db.Column(db.BIGINT, db.ForeignKey("contract.Id"))
OrderId = db.Column(db.BIGINT, db.ForeignKey("order.Id"))
OrderType = db.Column(db.INT)
Contract = db.relation('Contract', lazy="joined", backref=db.backref('ContractOrder', lazy='dynamic'))
Order = db.relation('Order', lazy="joined")
def __init__(self, ContractId, OrderId, OrderType):
self.ContractId = ContractId
self.OrderId = OrderId
self.OrderType = OrderType
class ContractHistory(db.Model):
__tablename__ = "contracthistory"
Id = db.Column(db.BIGINT, primary_key=True)
ContractId = db.Column(db.BIGINT, db.ForeignKey('contract.Id'))
Version = db.Column(db.BIGINT)
RejectReason = db.Column(db.VARCHAR(1024))
RejectTime = db.Column(db.DATETIME)
ApplyRemark = db.Column(db.VARCHAR(1024))
ApplyTime = db.Column(db.DATETIME)
CreateTime = db.Column(db.TIMESTAMP)
Detail = db.Column(db.TEXT)
ModifyPerson = db.Column(db.VARCHAR(255))
Scheme = db.Column(db.TEXT)
Script = db.Column(db.TEXT)
DepositPercent = db.Column(db.FLOAT)
Contract = db.relation('Contract', backref=db.backref('ContractHistory', lazy='dynamic'))
class Requirement(db.Model):
__tablename__ = "requirement"
Id = db.Column(db.BIGINT, primary_key=True)
PublisherId = db.Column(db.BIGINT, db.ForeignKey('user.Id'))
ServiceUserId = db.Column(db.BIGINT, db.ForeignKey('user.Id'))
Title = db.Column(db.VARCHAR(255))
Detail = db.Column(db.TEXT)
Amount = db.Column(db.FLOAT)
Status = db.Column(db.INT, db.ForeignKey('segment.Id'))
CreateTime = db.Column(db.TIMESTAMP)
Publisher = db.relation('User', backref=db.backref('Requirements', lazy='dynamic'),
foreign_keys='Requirement.PublisherId', lazy='joined')
Deadline = db.Column(db.VARCHAR(20))
Type = db.Column(db.VARCHAR(20))
Long = db.Column(db.VARCHAR(100))
Format = db.Column(db.VARCHAR(100))
Voice = db.Column(db.VARCHAR(2048))
Gbm = db.Column(db.VARCHAR(2048))
Place = db.Column(db.VARCHAR(20))
Refer = db.Column(db.VARCHAR(100))
ReferName = db.Column(db.VARCHAR(100))
Symbol = db.Column(db.VARCHAR(20))
Subtitle = db.Column(db.VARCHAR(2048))
Category_1 = db.Column(db.INT)
Category_2 = db.Column(db.INT)
Scheme = db.Column(db.TEXT)
ContractId = db.Column(db.INT)
DepositPercent = db.Column(db.FLOAT)
Star = db.Column(db.INT)
Comment = db.Column(db.VARCHAR(255))
Remark = db.Column(db.TEXT)
ApplyStatus = db.Column(db.INT)
IsFinalPay = db.Column(db.INT)
IsAdvancePay = db.Column(db.INT)
ServiceUser = db.relation('User', foreign_keys='Requirement.ServiceUserId', lazy='joined')
CurSegment = db.relation('Segment', lazy='joined')
def __init__(self):
self.DepositPercent = 50.0
self.ApplyStatus = 0
self.IsFinalPay = 0
self.IsAdvancePay = 0
class EventTime (db.Model):
id = db.Column(db.Integer, primary_key=True)
date_id = db.Column(db.Integer, db.ForeignKey('date.id'))
date = db.relationship('Date', backref=db.backref('event_times', lazy='dynamic'))
time = db.Column(db.Integer)
def __init__(self, date, time):
self.date = date
self.time = time
def toString(self):
return str(self.time) + " : " + self.date.toString()
def __repr__(self):
return "<DateTime %r>" % self.toString()
def __str__(self):
return self.toString()
class Role(db.Model):
__tablename__ = "role"
Id = db.Column(db.Integer, primary_key=True)
DomainId = db.Column(db.Integer, db.ForeignKey("domain.Id"))
Name = db.Column(db.VARCHAR(255))
CreatorId = db.Column(db.Integer)
CreateTime = db.Column(db.TIMESTAMP)
DomainAdmin = db.Column(db.BOOLEAN)
Domain = db.relationship('Domain',
backref=db.backref('Roles', lazy='dynamic'))
def __init__(self, Name, DomainId, CreatorId, DomainAdmin):
self.Name = Name
self.DomainId = DomainId
self.CreatorId = CreatorId
self.DomainAdmin = DomainAdmin
# self.CreateTime='current_timestamp()'
def __repr__(self):
return '<Domain %r>' % {'Id': self.Id, 'DomainId': self.DomainId}
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 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 Domain(db.Model):
__tablename__ = "domain"
Id = db.Column(db.Integer, primary_key=True)
DomainName = db.Column(db.VARCHAR(255))
OwnerUserId = db.Column(db.Integer, db.ForeignKey('user.Id'))
ExpireTime = db.Column(db.DateTime)
CreateTime = db.Column(db.TIMESTAMP)
Alipay = db.Column(db.VARCHAR(50))
Status = db.Column(db.INT)
ShowType = db.Column(db.INT)
CompanyName = db.Column(db.VARCHAR(255))
CompanyAddr = db.Column(db.VARCHAR(1024))
CompanyLicense = db.Column(db.VARCHAR(50))
CompanyPhone = db.Column(db.VARCHAR(15))
CompanyCelPhone = db.Column(db.VARCHAR(15))
CompanyFax = db.Column(db.VARCHAR(20))
CompanyEmail = db.Column(db.VARCHAR(100))
CompanyLicAttachment = db.Column(db.VARCHAR(255))
IsService = db.Column(db.BOOLEAN)
UsedSize = db.Column(db.BIGINT)
Intro = db.Column(db.VARCHAR(1024))
StarLevel = db.Column(db.INT)
ZoneName = db.Column(db.VARCHAR(255))
Focus = db.Column(db.INT)
Level = db.Column(db.INT)
Work = db.Column(db.INT)
Trade = db.Column(db.INT)
Count = db.Column(db.FLOAT)
DefaultStorageSize = db.Column(db.BIGINT)
ExtendStorageSize = db.Column(db.BIGINT)
ESExpireTime = db.Column(db.DATETIME)
MembershipTax = db.Column(db.BIGINT)
Price = db.Column(db.FLOAT)
Portrait = db.Column(db.VARCHAR(255))
Weight = db.Column(db.FLOAT)
ZoneBanner = db.Column(db.VARCHAR(255))
Users = db.relationship('User',
backref=db.backref('Domain',
lazy='joined',
uselist=False),
lazy='dynamic',
foreign_keys='User.DomainId')
def __init__(self, DomainName, OwnerUserId):
self.DomainName = DomainName + '\'s' # + '\'s family'
self.OwnerUserId = OwnerUserId
self.IsService = 0
self.Status = DomainStatus.init
self.ShowType = 0
self.CompanyName = DomainName
self.ExtendStorageSize = 0
self.ExpireTime = datetime.datetime.now()
self.ESExpireTime = datetime.datetime.now()
self.Intro = 'intro'
self.Portrait = '/image/contacts.png'
self.Trade = 0
self.Focus = 0
self.Price = 0
self.Weight = 0
self.Count = 0
def __repr__(self):
return '<Domain %r>' % {'Id': self.Id, 'DomainName': self.DomainName}
