class PointView(CVAdminModelView):
can_create = False
can_edit = False
can_delete = False
page_size = 100
column_filters = ('target', 'member_id', 'member_name', 'reporter_id', 'reporter_name', 'has_confirmed', 'date')
column_list = (
'botid', 'target', 'member', 'reporter', 'point', 'confirm_code', 'has_confirmed',
'date', 'time', 'update_at', 'message')
column_searchable_list = ('member_name', 'reporter_name')
column_labels = dict(botid = '机器人', target = '目标',
member = '成员', reporter = '报点人',
point = '点数', confirm_code = '确认码', has_confirmed = '已经确认',
date = '日期', time = '时间', create_at = '创建时间', update_at = '更新时间',
message = '消息')
column_formatters = dict(botid = lambda v, c, m, p: get_botname(m.botid),
target = lambda v, c, m, p: get_target_display(m.target),
member = lambda v, c, m, p: get_CQ_display(m.member_id + ' : ' + m.member_name),
reporter = lambda v, c, m, p: get_CQ_display(m.reporter_id + ' : ' + m.reporter_name),
has_confirmed = lambda v, c, m, p: get_yesno_display(m.has_confirmed),
date = lambda v, c, m, p: display_datetime(m.create_at, False),
time = lambda v, c, m, p: m.time.strftime('%H:%M'),
update_at = lambda v, c, m, p: display_datetime(m.update_at),
message = lambda v, c, m, p: get_CQ_display(m.message))
column_default_sort = ('id', True)
def __init__(self, model, session):
CVAdminModelView.__init__(self, model, session, '报点记录', '报点管理')
def get_query(self):
return get_list_by_botassign(Point, PointView, self)
def get_count_query(self):
return get_list_count_by_botassign(Point, PointView, self)
class ScoreMemberView(CVAdminModelView):
can_create = False
can_edit = False
can_delete = False
page_size = 100
column_filters = ('account', 'member_id', 'member_name', 'income', 'outgo',
'balance')
column_list = ('account', 'member', 'income', 'outgo', 'balance',
'record_count', 'create_at', 'update_at', 'remark')
column_searchable_list = ('member_name', 'remark')
column_labels = dict(account='账户名',
member='成员',
member_id='成员账号',
member_name='成员名称',
income='总收入',
outgo='总支出',
balance='余额',
record_count='交易次数',
create_at='创建时间',
update_at='更新时间',
remark='备注')
def _record_formatter(view, context, model, name):
cnt = ScoreRecord.find_by_member(model.member_id)
if cnt is not None:
return Markup(u"<a href= '%s'>%s</a>" % (url_for(
'scorerecord.index_view', flt2_16=model.member_id), cnt[0]))
else:
return 0
column_formatters = dict(
member=lambda v, c, m, p: get_CQ_display(m.member_id + ' : ' + m.
member_name),
record_count=_record_formatter,
create_at=lambda v, c, m, p: display_datetime(m.create_at),
update_at=lambda v, c, m, p: display_datetime(m.update_at))
column_default_sort = ('update_at', True)
def __init__(self, model, session):
CVAdminModelView.__init__(self, model, session, '成员积分', '积分管理')
def get_query(self):
return get_list_by_scoreaccount(ScoreMember, ScoreMemberView, self)
def get_count_query(self):
return get_list_count_by_scoreaccount(ScoreMember, ScoreMemberView,
self)
class SignView(CVAdminModelView):
can_create = False
can_edit = False
can_delete = False
page_size = 100
column_filters = ('target', 'member_id', 'member_name', 'date')
column_list = ('botid', 'target', 'member', 'date', 'time', 'message')
column_searchable_list = ('member_name', )
column_labels = dict(botid='机器人',
target='目标',
member='成员',
member_id='成员账号',
member_name='成员名称',
date='日期',
time='时间',
message='消息')
column_formatters = dict(
botid=lambda v, c, m, p: get_botname(m.botid),
target=lambda v, c, m, p: get_target_display(m.target),
member=lambda v, c, m, p: get_CQ_display(m.member_id + ' : ' + m.
member_name),
message=lambda v, c, m, p: get_CQ_display(m.message),
date=lambda v, c, m, p: display_datetime(m.create_at, False),
time=lambda v, c, m, p: m.time.strftime('%H:%M'))
column_default_sort = ('id', True)
def __init__(self, model, session):
CVAdminModelView.__init__(self, model, session, '签到记录', '消息管理')
def get_query(self):
return get_list_by_botassign(Sign, SignView, self)
def get_count_query(self):
return get_list_count_by_botassign(Sign, SignView, self)
class PointConfirmView(CVAdminModelView):
can_create = False
can_edit = False
can_delete = True
page_size = 100
column_filters = ('target', 'expire_at')
column_list = (
'botid', 'target', 'point', 'confirm_code', 'expire_at')
column_searchable_list = ('confirm_code',)
column_labels = dict(botid = '机器人', target = '目标',
point = '报点记录', confirm_code = '确认码', expire_at = '过期时间')
column_formatters = dict(botid = lambda v, c, m, p: get_botname(m.botid),
target = lambda v, c, m, p: get_target_display(m.target),
point = lambda v, c, m, p: m.point_id,
expire_at = lambda v, c, m, p: display_datetime(m.expire_at))
column_default_sort = ('id', True)
def __init__(self, model, session):
CVAdminModelView.__init__(self, model, session, '待确认队列', '报点管理')
def get_query(self):
return get_list_by_botassign(PointConfirm, PointConfirmView, self)
def get_count_query(self):
return get_list_count_by_botassign(PointConfirm, PointConfirmView, self)
class BotView(CVAdminModelView):
can_create = True
can_edit = True
can_delete = True
column_display_pk = True
column_labels = dict(id='机器人ID',
name='名称',
active='启用',
create_at='创建时间',
update_at='更新时间',
remark='备注')
column_formatters = dict(
active=lambda v, c, m, p: get_yesno_display(m.active),
create_at=lambda v, c, m, p: display_datetime(m.create_at),
update_at=lambda v, c, m, p: display_datetime(m.update_at))
form_edit_rules = ('id', 'name', 'active', 'remark')
form_create_rules = ('id', 'name', 'active', 'remark')
def __init__(self, model, session):
CVAdminModelView.__init__(self, model, session, '机器人', '系统设置')
def is_accessible(self):
from common.login import admin_permission
if admin_permission.can():
return login.current_user.is_authenticated
else:
return False
def get_create_form(self):
form = self.scaffold_form()
form.id = StringField('机器人ID',
[validators.required(message='机器人ID是必填字段')])
form.active = fields.BooleanField(
'启用状态', [validators.required(message='启用状态是必填字段')], default=True)
return form
def get_edit_form(self):
form = self.scaffold_form()
form.id = StringField('机器人ID', render_kw={'readonly': True})
form.active = fields.BooleanField(
'启用状态', [validators.required(message='启用状态是必填字段')], default=True)
return form
def after_model_delete(self, model):
Bot.destroy(model.id)
class BotParamView(CVAdminModelView):
column_display_pk = True
column_filters = ('name', )
column_labels = dict(botid='机器人',
name='参数名',
value='参数值',
create_at='创建时间',
update_at='更新时间',
remark='备注')
column_formatters = dict(
botid=lambda v, c, m, p: get_botname(m.botid),
create_at=lambda v, c, m, p: display_datetime(m.create_at),
update_at=lambda v, c, m, p: display_datetime(m.update_at))
form_columns = ('value', 'remark')
# from login.login_control import admin_permission
# try:
# if admin_permission.can():
# can_create = True
# can_edit = True
# can_delete = True
# else:
# can_create = False
# can_edit = False
# can_delete = False
# except:
# can_create = False
# can_edit = False
# can_delete = False
def __init__(self, model, session):
CVAdminModelView.__init__(self, model, session, '机器人参数', '机器人设置')
def get_query(self):
return get_list_by_botassign(BotParam, BotParamView, self)
def get_count_query(self):
return get_list_count_by_botassign(BotParam, BotParamView, self)
class BasedataView(CVAdminModelView):
can_create = True
can_edit = True
can_delete = True
column_labels = dict(code = '代码', name = '名称', value = '值', type = '类型', create_at = '创建时间', update_at = '更新时间',
remark = '备注')
column_formatters = dict(create_at = lambda v, c, m, p: display_datetime(m.create_at),
update_at = lambda v, c, m, p: display_datetime(m.update_at))
form_edit_rules = ('type', 'code', 'name', 'value', 'remark')
form_create_rules = ('type', 'code', 'name', 'value', 'remark')
column_default_sort = ('type')
def __init__(self, model, session):
CVAdminModelView.__init__(self, model, session, '基础数据', '系统设置')
def is_accessible(self):
from common.login import admin_permission
if admin_permission.can():
return login.current_user.is_authenticated
else:
return False
class ScoreRecordView(CVAdminModelView):
can_create = False
can_edit = False
can_delete = False
page_size = 100
column_filters = ('account', 'trans_type', 'member_id', 'amount',
'biz_type', 'date')
column_list = ('account', 'biz_type', 'trans_type', 'member', 'before',
'amount', 'after', 'date', 'time', 'remark')
column_searchable_list = ('member_name', 'remark')
column_labels = dict(account='账户名',
biz_type='来源类型',
trans_type='交易类型',
member='成员',
member_id='成员账号',
member_name='成员名称',
amount='交易数量',
before='交易前余额',
after='交易后余额',
date='日期',
time='时间',
remark='备注')
column_formatters = dict(
target=lambda v, c, m, p: get_target_display(m.target),
biz_type=lambda v, c, m, p: ScoreRule.get_rule(m.account, m.biz_type
).description,
trans_type=lambda v, c, m, p: get_transtype_display(
m.trans_type, m.amount < 0),
member=lambda v, c, m, p: get_CQ_display(m.member_id + ' : ' + m.
member_name),
amount=lambda v, c, m, p: abs(m.amount),
date=lambda v, c, m, p: display_datetime(m.create_at, False),
time=lambda v, c, m, p: m.time.strftime('%H:%M'))
column_default_sort = ('id', True)
def __init__(self, model, session):
CVAdminModelView.__init__(self, model, session, '积分记录', '积分管理')
def get_query(self):
return get_list_by_scoreaccount(ScoreRecord, ScoreRecordView, self)
def get_count_query(self):
return get_list_count_by_scoreaccount(ScoreRecord, ScoreRecordView,
self)
class TargetRuleView(CVAdminModelView):
__type_list = {'allow': '允许', 'block': '拒绝'}
can_create = True
can_edit = True
can_delete = True
column_filters = ('type', )
column_labels = dict(id='ID',
botid='机器人',
type='类型',
target='目标',
create_at='创建时间',
update_at='更新时间',
remark='备注')
column_formatters = dict(
create_at=lambda v, c, m, p: display_datetime(m.create_at),
update_at=lambda v, c, m, p: display_datetime(m.update_at),
type=lambda v, c, m, p: v.__type_list[m.type],
target=lambda v, c, m, p: get_target_display(m.target),
botid=lambda v, c, m, p: get_botname(m.botid))
form_create_rules = (
rules.FieldSet(('botid', 'type', 'remark'), '基本信息'),
rules.FieldSet(('target_type', 'target_account'), '目标设置'),
)
form_edit_rules = (
rules.FieldSet(('botid', 'type', 'remark'), '基本信息'),
rules.FieldSet(('target_type', 'target_account'), '目标设置'),
)
def __init__(self, model, session):
CVAdminModelView.__init__(self, model, session, '目标规则设置', '机器人设置')
def get_query(self):
return get_list_by_botassign(TargetRule, TargetRuleView, self)
def get_count_query(self):
return get_list_count_by_botassign(TargetRule, TargetRuleView, self)
def get_create_form(self):
form = self.scaffold_form()
delattr(form, 'target')
form.target_type = fields.SelectField('目标类型',
coerce=str,
choices=get_target_type_choice(),
widget=Select2Widget())
form.target_account = fields.StringField(
'目标账号', [validators.required(message='目标账号是必填字段')])
form.type = fields.SelectField(
'类型', [validators.required(message='类型是必填字段')],
coerce=str,
choices=self.__type_list.items(),
widget=Select2Widget())
def query_factory():
from flask_login import current_user
from common.bot import BotAssign
return [
r.botid for r in BotAssign.find_by_user(current_user.username)
]
def get_pk(obj):
return obj
def get_label(obj):
return Bot.find(obj).name
from wtforms.ext.sqlalchemy.fields import QuerySelectField
form.botid = QuerySelectField(
'机器人', [validators.required(message='机器人是必填字段')],
query_factory=query_factory,
get_label=get_label,
get_pk=get_pk,
widget=Select2Widget())
return form
def get_edit_form(self):
form = self.scaffold_form()
# delattr(form, 'target')
form.target_type = fields.SelectField(
'目标类型', [validators.required(message='目标类型是必填字段')],
coerce=str,
choices=get_target_type_choice(),
widget=Select2Widget())
form.target_account = fields.StringField(
'目标账号', [validators.required(message='目标账号是必填字段')])
form.type = fields.SelectField(
'类型', [validators.required(message='类型是必填字段')],
coerce=str,
choices=self.__type_list.items(),
widget=Select2Widget())
form.botid = fields.StringField('机器人ID', render_kw={'readonly': True})
def query_factory():
return self.model.find_by_id()
return form
def on_model_change(self, form, model, is_created):
model.target = get_target_composevalue(form.target_type.data,
form.target_account.data)
def on_form_prefill(self, form, id):
# form.botid.label = Bot.find(form.botid.data).name
target = self.model.find_by_id(id).target
form.target_account.data = target.replace(target[0:2], '')
class APIKeyView(CVAdminModelView):
can_create = True
can_edit = False
can_delete = True
column_labels = dict(id='ID',
botid='机器人',
key='API Key',
secret='API Secret',
create_at='创建时间',
update_at='更新时间')
column_formatters = dict(
botid=lambda v, c, m, p: get_botname(m.botid),
create_at=lambda v, c, m, p: display_datetime(m.create_at),
update_at=lambda v, c, m, p: display_datetime(m.update_at))
column_extra_row_actions = [
EndpointLinkRowAction('fa fa-refresh',
'apikey.refresh_view',
title='更新Key和Secret')
]
form_create_rules = ('botid', )
form_edit_rules = ('botid', 'new_key', 'new_secret')
def __init__(self, model, session):
CVAdminModelView.__init__(self, model, session, 'API密钥', '系统设置')
def is_accessible(self):
from common.login import admin_permission
if admin_permission.can():
return login.current_user.is_authenticated
else:
return False
def get_create_form(self):
form = self.scaffold_form()
def query_factory():
return [r.id for r in Bot.findall()]
def get_pk(obj):
return obj
def get_label(obj):
return Bot.find(obj).name
from wtforms.ext.sqlalchemy.fields import QuerySelectField
form.botid = QuerySelectField(
'机器人', [validators.required(message='机器人是必填字段')],
query_factory=query_factory,
get_label=get_label,
get_pk=get_pk,
widget=Select2Widget())
return form
def get_edit_form(self):
form = self.scaffold_form()
delattr(form, 'key')
delattr(form, 'secret')
form.botid = StringField('机器人', render_kw={'readonly': True})
form.new_key = StringField('新API Key', render_kw={'readonly': True})
form.new_secret = StringField('新API Secret',
render_kw={'readonly': True})
return form
def on_form_prefill(self, form, id):
form.new_key.data = generate_key(32, True, False, True)
form.new_secret.data = generate_key(12, False, True, True)
def on_model_change(self, form, model, is_created):
if not is_created:
if form.new_key.data:
model.key = form.new_key.data
model.secret = form.new_secret.data
@expose('/refresh/', methods=('GET', 'POST'))
def refresh_view(self):
"""
Refresh key and secret
"""
return_url = get_redirect_target() or self.get_url('.index_view')
id = get_mdict_item_or_list(request.args, 'id')
if id is not None:
self.get_one(id).refresh()
return redirect(return_url)
class RoleView(CVAdminModelView):
can_create = True
can_edit = True
can_delete = True
# column_auto_select_related = True
# from common.user import User
# # inline_models =[(User, dict(
# # column_descriptions=dict(users='用户')
# # ))]
# # inline_models = [(User, dict(form_columns = ['id', 'username', 'email']))]
#
# from flask_admin.model.form import InlineFormAdmin
# class MyInlineModelForm(InlineFormAdmin):
# form_columns = ('id', 'username', 'email', 'active', 'remark')
# # column_labels = dict(id = '用户ID', username = '******', password = '******',
# # email = '邮箱地址', roles = '角色', active = '启用',
# # create_at = '创建时间', update_at = '更新时间', remark = '备注')
#
# def postprocess_form(self, form):
# # form_create_rules = (
# # rules.FieldSet(('username', 'email','remark'), '基本信息'),
# # rules.FieldSet(('active',), '权限设置'),
# # )
# # self._form_rules = rules.RuleSet(self, form_create_rules)
# form.username = fields.StringField('用户名', [validators.required(message = '用户名是必填字段')])
# form.email = fields.StringField('邮箱地址')
# form.active = fields.BooleanField('启用状态', [validators.required(message = '启用状态是必填字段')], default = True)
# form.remark = fields.StringField('备注')
# return form
#
# inline_models = (MyInlineModelForm(User),)
column_list = ('id', 'name', 'description', 'users_count', 'create_at',
'update_at')
column_labels = dict(id='角色ID',
name='角色名',
description='详述',
create_at='创建时间',
update_at='更新时间',
users_count='用户数',
users='用户')
def _user_formatter(view, context, model, name):
cnt = User.find_by_role(model.name)
if cnt is not None:
return Markup(
u"<a href= '%s'>%s</a>" %
(url_for('user.index_view', flt1_0=model.name), cnt[0]))
else:
return 0
column_formatters = dict(
create_at=lambda v, c, m, p: display_datetime(m.create_at),
update_at=lambda v, c, m, p: display_datetime(m.update_at),
users_count=_user_formatter)
form_columns = ('name', 'description')
def __init__(self, model, session):
CVAdminModelView.__init__(self, model, session, '角色', '系统设置')
def is_accessible(self):
from common.login import admin_permission
if admin_permission.can():
return login.current_user.is_authenticated
else:
return False
class UserView(CVAdminModelView):
can_create = True
can_edit = True
can_delete = True
# inline_models = [(Role, dict(form_columns=['id', 'name']))]
column_list = ('id', 'username', 'password', 'email', 'roles', 'active',
'create_at', 'update_at', 'remark')
column_labels = dict(id='用户ID',
username='******',
password='******',
email='邮箱地址',
roles='角色',
active='启用',
create_at='创建时间',
update_at='更新时间',
remark='备注')
column_filters = ('roles.name', )
column_formatters = dict(
password=lambda v, c, m, p: '••••••',
active=lambda v, c, m, p: get_yesno_display(m.active),
create_at=lambda v, c, m, p: display_datetime(m.create_at),
update_at=lambda v, c, m, p: display_datetime(m.update_at))
# def get_action_url(self):
# self.get_url('.edit_view', id = self.get_pk_value(self.row),
# url = get_redirect_target() or self.get_url('.index_view'))
column_extra_row_actions = [
# LinkRowAction('fa fa-key','/admin/user/edit/?id={row_id}&url=%2Fadmin%2Fuser%2F'),
EndpointLinkRowAction('fa fa-key', 'user.resetpass_view', title='重置密码')
]
form_args = dict(roles=dict(validators=[DataRequired()]))
form_create_rules = (
rules.FieldSet(('username', 'email', 'remark'), '基本信息'),
# rules.FieldSet(('roles', 'apikey', 'active'), 'Permission'),
rules.FieldSet(('roles', 'active'), '权限设置'),
# rules.FieldSet(('password', 'password_confirm'), '账号安全')
)
form_edit_rules = (
rules.FieldSet(('username', 'email', 'remark'), '基本信息'),
rules.FieldSet(('roles', 'active'), '权限设置'),
# rules.Header('重置密码'),
# rules.FieldSet(('new_password', 'new_password_confirm'), '重置密码')
# rules.Field()
)
def __init__(self, model, session):
CVAdminModelView.__init__(self, model, session, '用户', '系统设置')
def is_accessible(self):
from common.login import admin_permission
if request.endpoint == 'user.resetpass_view':
if (login.current_user.id == int(
request.values.get('id'))) or admin_permission.can():
return login.current_user.is_authenticated
else:
return False
else:
if admin_permission.can():
return login.current_user.is_authenticated
else:
return False
def get_create_form(self):
form = self.scaffold_form()
form.username = fields.StringField(
'用户名', [validators.required(message='用户名是必填字段')])
# form.password = fields.PasswordField('密码', [validators.required(message = '密码是必填字段')])
# form.password_confirm = fields.PasswordField('密码确认',
# [validators.required(message = '密码是必填字段'),
# validators.equal_to(fieldname = 'password',
# message = '确认密码须一致')])
form.active = fields.BooleanField(
'启用状态', [validators.required(message='启用状态是必填字段')], default=True)
return form
def get_edit_form(self):
form = self.scaffold_form()
delattr(form, 'password')
# form.new_password = fields.PasswordField('新密码')
# form.new_password_confirm = fields.PasswordField('密码确认',
# [validators.equal_to(fieldname = 'new_password',
# message = '确认密码须一致')])
form.active = fields.BooleanField(
'启用状态', [validators.required(message='启用状态是必填字段')], default=True)
return form
def on_model_change(self, form, model, is_created):
if not is_created:
if hasattr(form, 'new_password'):
model.password = generate_password_hash(form.new_password.data)
else:
model.password = generate_password_hash(model.password)
def get_action_form(self):
'''
定制Action
:return:
'''
class ResetpassForm(self.form_base_class):
form_widget_args = {}
form_edit_rules = [
rules.Field('new_password'),
rules.Field('new_password_confirm')
]
_form_edit_rules = rules.RuleSet(self, form_edit_rules)
action = HiddenField('')
url = HiddenField('')
new_password = fields.PasswordField(
'新密码', [validators.required(message='密码是必填字段')])
new_password_confirm = fields.PasswordField(
'密码确认', [
validators.equal_to(fieldname='new_password',
message='确认密码须一致')
])
return ResetpassForm
@expose('/resetpass/', methods=('GET', 'POST'))
def resetpass_view(self):
"""
Reset password view
"""
return_url = get_redirect_target() or self.get_url('.index_view')
if not self.can_edit:
return redirect(return_url)
id = get_mdict_item_or_list(request.args, 'id')
if id is None:
return redirect(return_url)
model = self.get_one(id)
if model is None:
flash(gettext('Record does not exist.'), 'error')
return redirect(return_url)
form = self.action_form(obj=model)
if not hasattr(form,
'_validated_ruleset') or not form._validated_ruleset:
self._validate_form_instance(ruleset=form._form_edit_rules,
form=form)
if self.validate_form(form):
if self.update_model(form, model):
flash(gettext('Record was successfully saved.'), 'success')
if '_add_another' in request.form:
return redirect(
self.get_url('.create_view', url=return_url))
elif '_continue_editing' in request.form:
return redirect(request.url)
else:
# save button
return redirect(
self.get_save_return_url(model, is_created=False))
if request.method == 'GET' or form.errors:
self.on_form_prefill(form, id)
form_opts = FormOpts(widget_args=form.form_widget_args,
form_rules=form._form_edit_rules)
template = 'model/resetpass.html'
return self.render(template,
model=model,
form=form,
form_opts=form_opts,
return_url=return_url)
class ScoreRuleView(CVAdminModelView):
can_create = True
can_edit = True
can_delete = True
column_filters = ('account', 'code', 'type')
column_list = ('account', 'code', 'description', 'type', 'amount',
'create_at', 'update_at', 'remark')
column_searchable_list = ('description', 'remark')
column_labels = dict(account='账户名',
code='规则码',
description='描述',
type='类型',
amount='数量',
create_at='创建时间',
update_at='更新时间',
remark='备注')
column_formatters = dict(
create_at=lambda v, c, m, p: display_datetime(m.create_at),
update_at=lambda v, c, m, p: display_datetime(m.update_at),
type=lambda v, c, m, p: get_acttype_display(m.type))
form_columns = ('account', 'code', 'description', 'type', 'amount',
'remark')
def __init__(self, model, session):
CVAdminModelView.__init__(self, model, session, '积分规则设置', '机器人设置')
def get_query(self):
return get_list_by_scoreaccount(ScoreRule, ScoreRuleView, self)
def get_count_query(self):
return get_list_count_by_scoreaccount(ScoreRule, ScoreRuleView, self)
def get_create_form(self):
form = self.scaffold_form()
def query_factory():
from flask_login import current_user
return [
r.name
for r in ScoreAccount.find_by_user(current_user.username)
]
def get_pk(obj):
return obj
def get_label(obj):
return obj
from wtforms.ext.sqlalchemy.fields import QuerySelectField
form.account = QuerySelectField(
'账户名', [validators.required(message='账户名是必填字段')],
query_factory=query_factory,
get_label=get_label,
get_pk=get_pk,
widget=Select2Widget())
form.code = fields.StringField(
'规则码', [validators.required(message='规则码是必填字段')])
form.description = fields.StringField('描述')
form.type = fields.SelectField('类型',
coerce=str,
choices=get_acttype_choice(),
widget=Select2Widget())
form.amount = fields.StringField(
'数量', [validators.required(message='数量是必填字段')])
form.remark = fields.StringField('备注')
return form
def get_edit_form(self):
form = self.scaffold_form()
form.account = fields.StringField('账户名', render_kw={'readonly': True})
form.code = fields.StringField('规则码', render_kw={'readonly': True})
form.type = fields.SelectField('类型',
coerce=str,
choices=get_acttype_choice(),
widget=Select2Widget())
form.description = fields.StringField('描述')
form.type = fields.SelectField('类型',
coerce=str,
choices=get_acttype_choice(),
widget=Select2Widget())
form.amount = fields.StringField(
'数量', [validators.required(message='数量是必填字段')])
form.remark = fields.StringField('备注')
return form
class ScoreAccountView(CVAdminModelView):
can_create = True
can_edit = True
can_delete = True
page_size = 100
column_filters = (
'target',
# 'type',
'is_default',
'income',
'outgo',
'balance')
column_list = (
'botid',
'name',
'description',
# 'type',
'is_default',
'target',
'income',
'outgo',
'balance',
'create_at',
'update_at',
'remark')
column_searchable_list = ('name', 'description', 'remark')
column_labels = dict(
botid='机器人',
name='账户名',
description='账户描述',
# type = '账户类型',
is_default='缺省账户',
target='目标',
income='总收入',
outgo='总支出',
balance='余额',
create_at='创建时间',
update_at='更新时间',
remark='备注')
column_formatters = dict(
botid=lambda v, c, m, p: get_botname(m.botid),
target=lambda v, c, m, p: get_target_display(m.target),
create_at=lambda v, c, m, p: display_datetime(m.create_at),
update_at=lambda v, c, m, p: display_datetime(m.update_at),
# type = lambda v, c, m, p: get_acttype_display(m.type),
is_default=lambda v, c, m, p: get_yesno_display(m.is_default))
form_columns = (
'botid',
'name',
'description',
# 'type',
'is_default',
'target',
'remark')
form_create_rules = (
rules.FieldSet(('botid', 'target'), '目标设置'),
rules.FieldSet(('name', 'description', 'remark'), '基本信息'),
rules.FieldSet(
(
# 'type',
'is_default', ),
'其他选项'))
form_edit_rules = (
rules.FieldSet(('botid', 'target'), '目标设置'),
rules.FieldSet(('name', 'description', 'remark'), '基本信息'),
rules.FieldSet(
(
# 'type',
'is_default', ),
'其他选项'))
# form_choices = {'is_default': get_yesno_choice(),
# 'type': get_acttype_choice()}
def __init__(self, model, session):
CVAdminModelView.__init__(self, model, session, '积分账户设置', '机器人设置')
def get_query(self):
return get_list_by_botassign(ScoreAccount, ScoreAccountView, self)
def get_count_query(self):
return get_list_count_by_botassign(ScoreAccount, ScoreAccountView,
self)
def get_create_form(self):
form = self.scaffold_form()
# delattr(form, 'target')
# form.target_type = fields.SelectField('目标类型', coerce = str, choices = get_target_type_choice())
# form.target_account = fields.StringField('目标账号', [validators.required(message = '目标账号是必填字段')])
form.type = fields.SelectField('类型',
coerce=str,
choices=get_acttype_choice(),
widget=Select2Widget())
form.is_default = fields.BooleanField('缺省账户')
def bot_query_factory():
from flask_login import current_user
from common.bot import BotAssign
return [
r.botid for r in BotAssign.find_by_user(current_user.username)
]
def bot_get_pk(obj):
return obj
def bot_get_label(obj):
from common.bot import Bot
return Bot.find(obj).name
from wtforms.ext.sqlalchemy.fields import QuerySelectField
form.botid = QuerySelectField(
'机器人', [validators.required(message='机器人是必填字段')],
query_factory=bot_query_factory,
get_label=bot_get_label,
get_pk=bot_get_pk,
widget=Select2Widget())
def target_query_factory():
from flask_login import current_user
from plugins.setting import TargetRule
return [
r.botid + '|' + r.target
for r in TargetRule.find_allow_by_user(current_user.username)
]
def target_get_pk(obj):
return obj
def target_get_label(obj):
return get_target_display(obj.split('|')[1])
from wtforms.ext.sqlalchemy.fields import QuerySelectField
form.target = QuerySelectField(
'目标', [validators.required(message='目标是必填字段')],
query_factory=target_query_factory,
get_label=target_get_label,
get_pk=target_get_pk,
widget=Select2Widget())
return form
def get_edit_form(self):
form = self.scaffold_form()
form.botid = fields.StringField('机器人', render_kw={'readonly': True})
form.target = fields.StringField('目标', render_kw={'readonly': True})
form.name = fields.StringField('账户名', render_kw={'readonly': True})
form.type = fields.SelectField('类型',
coerce=str,
choices=get_acttype_choice(),
widget=Select2Widget())
form.is_default = fields.BooleanField('缺省账户')
return form
def on_model_change(self, form, model, is_created):
if is_created:
model.target = form.target.data.split('|')[1]
else:
model.botid = Bot.find_by_name(model.botid).id
model.target = recover_target_value(model.target)
def on_form_prefill(self, form, id):
form.botid.data = Bot.find(form.botid.data).name
form.target.data = get_target_display(form.target.data)
class BotAssignView(CVAdminModelView):
can_create = True
can_edit = True
can_delete = True
column_display_pk = True
column_labels = dict(botid='机器人',
username='******',
create_at='创建时间',
update_at='更新时间',
remark='备注')
column_formatters = dict(
botid=lambda v, c, m, p: get_botname(m.botid),
create_at=lambda v, c, m, p: display_datetime(m.create_at),
update_at=lambda v, c, m, p: display_datetime(m.update_at))
form_edit_rules = ('botid', 'botname', 'username', 'remark')
form_create_rules = ('botid', 'username', 'remark')
def __init__(self, model, session):
CVAdminModelView.__init__(self, model, session, '机器人分派', '系统设置')
def is_accessible(self):
from common.login import admin_permission
if admin_permission.can():
return login.current_user.is_authenticated
else:
return False
def get_create_form(self):
form = self.scaffold_form()
def bot_query_factory():
return [r.id for r in Bot.findall()]
def bot_get_pk(obj):
return obj
def bot_get_label(obj):
return Bot.find(obj).name
from wtforms.ext.sqlalchemy.fields import QuerySelectField
form.botid = QuerySelectField(
'机器人', [validators.required(message='机器人是必填字段')],
query_factory=bot_query_factory,
get_label=bot_get_label,
get_pk=bot_get_pk,
widget=Select2Widget())
from common.user import User
def user_query_factory():
return [r.username for r in User.findall()]
def user_get_pk(obj):
return obj
form.username = QuerySelectField(
'用户名', [validators.required(message='用户名是必填字段')],
query_factory=user_query_factory,
get_pk=user_get_pk,
widget=Select2Widget())
return form
def get_edit_form(self):
form = self.scaffold_form()
form.botid = fields.StringField('机器人ID', render_kw={'readonly': True})
form.botname = fields.StringField('机器人名称',
render_kw={'readonly': True})
# form.botname.data = get_botname(form.botid.data)
form.username = fields.StringField('用户名', render_kw={'readonly': True})
return form
def on_form_prefill(self, form, id):
form.botname.data = get_botname(id.split(',')[0])
def after_model_change(self, form, model, is_created):
BotAssign.init_relation(model.botid)
def after_model_delete(self, model):
BotAssign.destroy(model.botid)