class VSProject(CRUDMixin, db.Model):
""""
项目模型
"""
__tablename__ = 'tbl_sqlalchemy_project'
# 项目访问权限 open: 公开 private: 私有
access = db.Column(db.String(20), default='open')
# 创建时间
created_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 更新时间
updated_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 激活状态
active = db.Column(db.Boolean(), default=True)
# many to many
users = db.relationship(
"VSUser",
# 默认userlist=false为一对多关系,userlist=true为多对多关系
uselist=True,
secondary=project_user_association_table,
backref="projects",
# 关联的user表记录也会删除
cascade="save-update, merge, delete")
def __init__(self, **kwargs):
super(VSProject, self).__init__(**kwargs)
class VSGroup(CRUDMixin, db.Model):
"""
组模型
"""
__tablename__ = 'tbl_vsppm_group'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# 组名称
name = db.Column(db.String(128), nullable=False, unique=True)
# 组负责人
admin = db.Column(db.String(60))
# 所属部门id
department_id = db.Column(db.Integer, nullable=False)
# 创建时间
created_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 更新时间
updated_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 激活状态
active = db.Column(db.Boolean(), default=True)
def __init__(self, **kwargs):
super(VSGroup, self).__init__(**kwargs)
def __repr__(self):
return '<VSGroup #%s:%r>' % (self.id, self.name)
class VSAcl(CRUDMixin, db.Model):
"""
权限模型
"""
__tablename__ = 'tbl_vsppm_acl'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# 权限模块名称
module = db.Column(db.String(128), nullable=False)
# 权限模块功能方法名称
method = db.Column(db.String(128), nullable=False)
# 创建时间
created_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 更新时间
updated_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 激活状态
active = db.Column(db.Boolean(), default=True)
def __init__(self, **kwargs):
super(VSAcl, self).__init__(**kwargs)
def __repr__(self):
return '<VSAcl #%s:%r:%r>' % (self.id, self.module, self.method)
class VSRole(CRUDMixin, db.Model):
"""
角色模型
"""
__tablename__ = 'tbl_vsppm_role'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# 角色名称
name = db.Column(db.String(128), nullable=False, unique=True)
# 角色描述
role = db.Column(db.String(128), nullable=False)
# 创建时间
created_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 更新时间
updated_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 激活状态
active = db.Column(db.Boolean(), default=True)
# 让VSRole和VSAcl产生关联
# 因为VSAcl和VSRole表中间还有一个vsppm_user_role表,所以添加secondary
# 正向引用是VSRole访问VSAcl,反向引用是从VSAcl访问表VSRole
acls = db.relationship('VSAcl',
secondary=vsppm_role_acl,
backref=db.backref('roles'))
def __init__(self, **kwargs):
super(VSRole, self).__init__(**kwargs)
def __repr__(self):
return '<VSRole #%s:%r>' % (self.id, self.name)
class Category(CRUDMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(250), nullable=False, unique=True)
created_ts = db.Column(db.DateTime(timezone=True),
server_default=db.func.current_timestamp(),)
updated_ts = db.Column(db.DateTime(timezone=True),
onupdate=db.func.current_timestamp(),)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', backref='category')
def __init__(self, name, user_id):
self.name = name
self.created_ts = datetime.datetime.now()
self.user_id = user_id
def __repr__(self):
return '<Category %s>' % self.name
@property
def serialize(self):
"""Return object data in easily serializeable format"""
return {
'name': self.name,
'id': self.id,
}
@classmethod
def getCategories(cls):
list = cls.query.order_by(asc(cls.name))
return list
@classmethod
def getCurrentCategory(cls, category_id):
category = cls.query.filter_by(id=category_id).one()
return category
class User(CRUDMixin, UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), nullable=False, unique=True)
email = db.Column(db.String(128), nullable=False, unique=True)
pw_hash = db.Column(db.String(60), nullable=False)
created_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
updated_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
remote_addr = db.Column(db.String(20))
active = db.Column(db.Boolean())
is_admin = db.Column(db.Boolean())
def __init__(self, password, **kwargs):
super(User, self).__init__(**kwargs)
self.set_password(password)
def __repr__(self):
return '<User #%s:%r>' % (self.id, self.username)
def set_password(self, password):
hash_ = bcrypt.generate_password_hash(password, 10).decode('utf-8')
self.pw_hash = hash_
def check_password(self, password):
return bcrypt.check_password_hash(self.pw_hash, password)
class Serial(db.Model):
__tablename__ = "serials"
id = db.Column(db.Integer, primary_key=True)
number = db.Column(db.Integer)
timestamp = db.Column(db.DateTime(), index=True, default=datetime.utcnow)
date = db.Column(db.Date(), default=datetime.utcnow().date)
name = db.Column(db.String(300), nullable=True)
n = db.Column(db.Boolean)
p = db.Column(db.Boolean)
# stands for proccessed , which be modified after been processed
pdt = db.Column(db.DateTime())
# Fix: adding pulled by feature to tickets
pulledBy = db.Column(db.Integer)
office_id = db.Column(db.Integer, db.ForeignKey('offices.id'))
task_id = db.Column(db.Integer, db.ForeignKey('tasks.id'))
def __init__(self,
number=100,
office_id=1,
task_id=1,
name=None,
n=False,
p=False,
pulledBy=0):
self.number = number
self.office_id = office_id
self.task_id = task_id
self.name = name
self.n = n
# fixing mass use tickets multi operators conflict
self.p = p
self.pulledBy = pulledBy
class VSCompany(CRUDMixin, db.Model):
"""
公司模型
"""
__tablename__ = 'tbl_vsppm_company'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# 公司名称
name = db.Column(db.String(128), nullable=False, unique=True)
# 公司负责人
admin = db.Column(db.String(60))
# 主页
website = db.Column(db.String(128))
# 创建时间
created_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 更新时间
updated_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 激活状态
active = db.Column(db.Boolean(), default=True)
def __init__(self, **kwargs):
super(VSCompany, self).__init__(**kwargs)
def __repr__(self):
return '<VSCompany #%s:%r>' % (self.id, self.name)
class User(db.Model):
__tablename__ = 'Users'
Id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
Name = db.Column(db.Text(), nullable=True)
Email = db.Column(db.Text(), nullable=False)
DisplayName = db.Column(db.Text(), nullable=True)
FamilyName = db.Column(db.Text(), nullable=True)
RegistrationDate = db.Column(db.DateTime(), nullable=False)
LastVisit = db.Column(db.DateTime(), nullable=False)
wished_markers = db.relationship('Marker',
secondary=wishlist_markers,
backref='wishers')
owned_markers = db.relationship('Marker',
secondary=my_markers,
backref='owners')
cart_markers = db.relationship('Cart', backref='user')
def to_dict(self):
data = {
'id': self.Id,
'email': self.Email,
'name': self.Name,
'display_name': self.DisplayName,
'family_name': self.FamilyName,
'registration_date': self.RegistrationDate,
'last_visit': self.LastVisit
}
return data
class User(CRUDMixin, UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(128), nullable=False, unique=True)
pw_hash = db.Column(db.String(60), nullable=False)
created_ts = db.Column(
db.DateTime(timezone=True),
server_default=db.func.current_timestamp(),
)
updated_ts = db.Column(
db.DateTime(timezone=True),
onupdate=db.func.current_timestamp(),
)
remote_addr = db.Column(db.String(20))
active = db.Column(db.Boolean())
is_admin = db.Column(db.Boolean())
def __init__(self,
email,
password,
remote_addr,
active=False,
is_admin=False):
self.email = email
self.set_password(password)
self.created_ts = datetime.datetime.now()
self.remote_addr = remote_addr
self.active = active
self.is_admin = is_admin
def __repr__(self):
return '<User %s>' % self.email
def set_password(self, password):
self.pw_hash = bcrypt.generate_password_hash(password,
10).decode("utf-8")
def check_password(self, password):
return bcrypt.check_password_hash(self.pw_hash, password)
@classmethod
def stats(cls):
active_users = cache.get('active_users')
if not active_users:
active_users = cls.query.filter_by(active=True).count()
cache.set('active_users', active_users)
inactive_users = cache.get('inactive_users')
if not inactive_users:
inactive_users = cls.query.filter_by(active=False).count()
cache.set('inactive_users', inactive_users)
return {
'all': active_users + inactive_users,
'active': active_users,
'inactive': inactive_users
}
class User(db.Model):
__tablename__ = 'users'
id = db.Column('id', db.Integer, primary_key = True)
ssnid = db.Column( db.Integer, unique=True, nullable=False)
customerid = db.Column(db.Integer, unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
name = db.Column(db.String(100))
addrln1 = db.Column(db.String(200), nullable=True)
addrln2 = db.Column(db.String(200), nullable=True)
city = db.Column(db.String(50))
state = db.Column(db.String(50))
pin = db.Column(db.String(10))
createdat = db.Column(db.DateTime(timezone=False), nullable=False, default=datetime.now)
updatedat = db.Column(db.DateTime(timezone=False), nullable=False, default=datetime.now, onupdate=datetime.now)
class VSUser(CRUDMixin, db.Model):
""""
账户模型
"""
__tablename__ = 'tbl_sqlalchemy_user'
account = db.Column(db.String(56), nullable=False, unique=True)
created_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
updated_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
active = db.Column(db.Boolean(), default=True)
def __init__(self, **kwargs):
super(VSUser, self).__init__(**kwargs)
class Recipe(CRUDMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(250), nullable=False)
description = db.Column(db.String(250))
image_url = db.Column(db.String(250))
created_ts = db.Column(
db.DateTime(timezone=True),
server_default=db.func.current_timestamp(),
)
updated_ts = db.Column(
db.DateTime(timezone=True),
onupdate=db.func.current_timestamp(),
)
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category', backref='recipe')
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', backref='recipe')
def __init__(self, name, user_id, category_id, description, image_url):
self.name = name
self.description = description
self.image_url = image_url
self.created_ts = datetime.datetime.now()
self.user_id = user_id
self.category_id = category_id
def __repr__(self):
return '<Recipe %s>' % self.name
@property
def serialize(self):
"""Return object data in easily serializeable format"""
return {
'name': self.name,
'description': self.description,
'image': self.image_url,
'id': self.id
}
@classmethod
def getRecipeList(self, category_id):
list = self.query.filter_by(category_id=category_id)
return list
@classmethod
def getCurrentRecipe(self, recipe_id):
recipe = self.query.filter_by(id=recipe_id).one()
return recipe
class Files(db.Model):
"""
Модель загруженных файлов
"""
__tablename__ = 'files'
id = db.Column(db.BigInteger,
primary_key=True,
nullable=False,
autoincrement=True,
comment='Id файла')
filename = db.Column(db.String(255), nullable=False, comment='Имя файла')
content_type = db.Column(db.String(255),
nullable=False,
comment='Тип изображения')
size = db.Column(db.BigInteger, nullable=False, comment='Размер в байтах')
checksum = db.Column(db.String(255),
nullable=False,
unique=True,
comment='Сумма файла')
created_at = db.Column(db.DateTime(),
nullable=False,
default=datetime.now(),
comment='Дата создания')
def __repr__(self):
return '<File %r>' % self.id
class User(db.Model, UserMixin):
"""
User model
Arguments:
id (int): Primary User Key
username (str): Unique username as chosen by the user
email (str): User's email address
password_hash (str): Users hashed password
"""
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(120), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def __repr__(self):
return '<User %r>' % self.username
def __str(self):
return self.username
class Report(CRUDMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(250), nullable=False, unique=False)
rd_query = db.Column(db.Text(), nullable=True)
created_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
updated_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
last_run = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
def __init__(self, rd_query=None, **kwargs):
super(Report, self).__init__(**kwargs)
if rd_query:
self.rd_query = rd_query
def __repr__(self):
return '<Report #%s:%r>' % (self.id, self.name)
class Office(db.Model):
__tablename__ = "offices"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Integer, unique=True)
timestamp = db.Column(db.DateTime(), index=True, default=datetime.utcnow)
prefix = db.Column(db.String(2))
def __init__(self, name, prefix):
self.name = name
self.prefix = prefix
class Task(db.Model):
__tablename__ = "tasks"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(300))
timestamp = db.Column(db.DateTime(), index=True, default=datetime.utcnow)
office_id = db.Column(db.Integer, db.ForeignKey('offices.id'))
def __init__(self, name, office_id):
self.name = name
self.office_id = office_id
class User(CRUDMixin, UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64))
phone_number = db.Column(db.String(64), unique=True, index=True, nullable=False)
registration_date = db.Column(db.DateTime(), default=datetime.utcnow)
password_hash = db.Column(db.String(128))
account = db.Column(db.Float, default=10.00)
role_id = db.Column(db.Integer,ForeignKey('roles.id'))
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
if self.role is None:
if self.phone_number == current_app.config['ADMIN_PHONENUMBER']:
self.role = Role.query.filter_by(permissions=0xff).first()
if self.role is None:
self.role = Role.query.filter_by(default=True).first()
@staticmethod
def insert_user_roles():
users = User.query.all()
for user in users:
if user.phone_number == current_app.config['ADMIN_PHONENUMBER']:
user.role = Role.query.filter_by(permissions=0xff).first()
db.session.commit()
@property
def password(self):
raise AttributeError('password is not a readable attribute')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
def __repr__(self):
return "User {}".format(self.name)
@staticmethod
def by_phoneNumber(phone_number):
return User.query.filter_by(phone_number=phone_number).first()
@staticmethod
def by_username(username):
return User.query.filter_by(username=username).first()
def deposit(self, amount):
self.account += amount
self.save()
def withdraw(self, amount):
self.account -= amount
self.save()
class Payment(db.Model):
__tablename__ = 'payment'
id = db.Column(db.Integer, primary_key=True)
amount = db.Column(db.Float)
currency = db.Column(db.String(3), nullable=False)
description = db.Column(db.String(1024), nullable=False)
created_at = db.Column(db.DateTime(timezone=True), default=db.func.now())
def __str__(self):
return 'Payment №%s' % self.id
class User(BaseModel, UserMixin):
__tablename__ = 'user'
username = db.Column(db.String(255), unique=True, index=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean(), index=True)
confirmed_at = db.Column(db.DateTime())
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(63))
current_login_ip = db.Column(db.String(63))
login_count = db.Column(db.Integer)
groups = db.relationship('Group',
secondary=groups_users,
backref=db.backref('users', lazy='dynamic'))
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def __repr__(self):
return '<User %r>' % self.username
class City(db.Model):
"""
城市
"""
__tablename__ = 'city'
name = db.Column(db.String(20))
desc = db.Column(db.String(200))
courseorg_id = db.Column(db.Integer, db.ForeignKey('courseorg.id'))
add_time = db.Column(db.DateTime(), default=datetime.now)
def __repr__(self):
return '<City {}>'.format(self.name)
class Notification(SurrogatePK, Model):
__tablename__ = 'notifications'
name = Column(db.String(128), index=True)
user_id = Column(db.Integer, db.ForeignKey('users.id'))
payload = Column(db.JSON)
timestamp = Column(db.DateTime(timezone=True), index=True, default=maya.now().datetime)
def __init__(self, name: str, user: '******', payload: Dict) -> None:
db.Model.__init__(self, name=name, user_id=user.id, payload=payload)
def update(self, commit=True, **kwargs):
kwargs['timestamp'] = maya.now().datetime()
super().update(commit, **kwargs)
class User(db.Model, UserMixin):
"""
Модель пользователей
"""
__tablename__ = 'users'
id = db.Column(db.BigInteger,
primary_key=True,
nullable=False,
autoincrement=True,
comment='ID пользователя')
name = db.Column(db.String(255),
nullable=False,
comment='Имя пользователя')
phone = db.Column(db.String(255),
nullable=False,
comment='Телефон пользователя')
email = db.Column(db.String(255),
nullable=False,
unique=True,
comment='Email пользователя')
password = db.Column(db.String(255),
nullable=False,
comment='Пароль пользователя')
created_at = db.Column(db.DateTime(),
nullable=False,
default=datetime.now(),
comment='Дата создания')
updated_at = db.Column(db.DateTime(),
nullable=False,
default=datetime.now(),
comment='Дата обновления')
confirmed = db.Column(db.Boolean(), default=False, comment='Подтвержден?')
def __repr__(self):
return '<User %r>' % self.name
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
username = db.Column(db.String(255))
password = db.Column(db.String(255))
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(100))
current_login_ip = db.Column(db.String(100))
login_count = db.Column(db.Integer)
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary='roles_users',
backref=db.backref('users', lazy='dynamic'))
def __repr__(self):
return '%r %r' % (self.username, self.email)
def get_setup(self):
return dict(key=self.id,
username=self.username,
email=self.email,
admin=self.is_admin())
def change_admin(self):
admin = Role.query.filter(Role.name == 'admin').first()
if admin in self.roles:
self.roles.remove(admin)
else:
self.roles.append(admin)
def is_admin(self):
roles = [each.name for each in self.roles]
if 'admin' in roles:
return True
return False
class CourseOrg(db.Model):
__tablename__ = 'courseOrg'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
desc = db.Column(db.Text)
category = db.Column(db.String(20), default='培训机构')
tag = db.Column(db.String(10), default='国内名校')
click_nums = db.Column(db.Integer, default=0)
fav_nums = db.Column(db.Integer, default=0)
address = db.Column(db.String(150))
city = db.relationship('City', backref='user', lazy='dynamic')
students = db.Column(db.Integer, default=0)
add_time = db.Column(db.DateTime(), default=datetime.now)
teachers = db.relationship('Teacher', backref='user', lazy='dynamic')
courses = db.relationship('Course', backref='courseOrg', lazy='dynamic')
def __repr__(self):
return '<City {}>'.format(self.name)
class Words(db.Model):
__tablename__ = 'words'
__table_args__ = (
db.UniqueConstraint("view_id", "word"),
)
id = db.Column(db.Integer, primary_key=True)
word = db.Column(db.String(255), nullable=False)
translation = db.Column(db.String(255), nullable=False)
url = db.Column(db.String(511), nullable=False)
created_on = db.Column(db.DateTime(), default=datetime.utcnow)
category_id = db.Column(db.Integer, db.ForeignKey('category.id', ondelete='CASCADE'), nullable=False)
category = db.relationship('Category', backref=db.backref('words', lazy=True))
view_id = db.Column(db.Integer, db.ForeignKey('view.id', ondelete='CASCADE'), nullable=False)
view = db.relationship('View', backref=db.backref('views', lazy=True))
def __repr__(self):
return '<Words %r>' % self.word
class KillHistory(Base):
__tablename__ = 'kill_history'
id = db.Column(db.Integer, primary_key=True)
total_kills = db.Column(db.VARCHAR(6))
time_stamp = db.Column(db.DateTime(timezone=True))
@classmethod
def get_total_kills(cls):
record = cls.query.first()
if record:
total = int(record.total_kills)
return total
@classmethod
def init_table(cls, **select):
if cls.query.first():
for record in cls.query.all():
db.session.delete(record)
db.session.commit()
record = cls.create(**select)
return record
@classmethod
def create(cls, **select):
record = cls(**select)
db.session.add(record)
db.session.commit()
return record
@classmethod
def update_record(cls, record=None, **insert):
status_update = False
record = record or cls.query.first()
for key, value in insert.items():
if getattr(record, key) != value:
print(key, getattr(record, key))
setattr(record, key, value)
status_update = True
if status_update:
db.session.add(record)
db.session.commit()
return record
class Teacher(db.Model):
"""
讲师
"""
__tablename__ = 'teacher'
id = db.Column(db.Integer, primary_key=True)
org_id = db.Column(db.Integer, db.ForeignKey('org.id'))
name = db.Column(db.String(50))
work_years = db.Column(db.Integer, default=0)
work_company = db.Column(db.String(50))
work_position = db.Column(db.String(50))
age = db.Column(db.Integer, default=0)
points = db.Column(db.String(50)) # 教学特点
click_nums = db.Column(db.Integer, default=0)
fav_nums = db.Column(db.Integer, default=0)
courses = db.relationship('Course', backref='teacher', lazy='dynamic')
add_time = db.Column(db.DateTime(), default=datetime.now)
def __repr__(self):
return '<Teacher {}>'.format(self.name)
class Feature(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(64))
description = db.Column(db.Text())
client = db.Column(db.String(24))
client_priority = db.Column(db.Integer())
target_date = db.Column(db.DateTime())
product_area = db.Column(db.String(24))
def to_json(self):
"""Return object data in easily serializeable format"""
return {
'id': self.id,
'title': self.title,
'description': self.description,
'client': self.client,
'client_priority': self.client_priority,
'target_date': dump_datetime(self.target_date),
'product_area': self.product_area
}
def __repr__(self):
return '<Feature {}>'.format(self.title)
