class GiftAdmin(ModelView):
form = GiftForm
can_view_details = True
details_modal = True
column_details_list = ('gift_id', 'product_id', 'credit_type', 'credit_value', 'on_sale')
column_list = ('gift_id', 'product_id', 'credit_type', 'credit_value', 'on_sale')
column_labels = dict(gift_id=u'礼物ID', product_id=u'物品', credit_type=u'价格类型',
credit_value=u'价格数值', on_sale=u'是否在售')
column_formatters = dict(
credit_type=lambda v, c, m, n: get_choices_desc(CREDIT_TYPE, m.credit_type),
product_id=lambda v, c, m, n: get_choices_desc(Product.all_gifts_for_admin(),
m.product_id)
)
def create_form(self, obj=None):
form = super(GiftAdmin, self).create_form(obj)
form.product_id.choices = Product.all_gifts_for_admin()
return form
def edit_form(self, obj=None):
form = super(GiftAdmin, self).edit_form(obj)
form.product_id.choices = Product.all_gifts_for_admin()
return form
def after_model_change(self, form, model, is_created):
super(GiftAdmin, self).after_model_change(form, model, is_created)
Redis.delete(ONSALE_GIFT_KEY)
def after_model_delete(self, model):
super(GiftAdmin, self).after_model_delete(model)
Redis.delete(ONSALE_GIFT_KEY)
class StoreAdmin(ModelView):
form = StoreForm
can_view_details = True
details_modal = True
column_details_list = ('store_id', 'store_type', 'title', 'credit_type', 'credit_value',
'status', 'begin_at', 'expire_at', 'action', 'campaign_id',
'resource_campaign_id', 'order', 'share_image', 'share_title')
column_list = ('store_id', 'store_type', 'title', 'credit_type', 'credit_value', 'status',
'campaign_id', 'resource_campaign_id', 'order')
column_labels = dict(store_id=u'商店ID', store_type=u'商店类型', title=u'标题', credit_type=u'价格类型',
credit_value=u'价格数值', status=u'状态', begin_at=u'开始时间',
expire_at=u'结束时间', campaign_id=u'营销平台活动ID',
resource_campaign_id=u'营销平台流量话费发放活动ID',
action=u'活动链接', order=u'显示顺序', share_image=u'分享图片', share_title=u'分享标题')
column_formatters = dict(
store_type=lambda v, c, m, n: get_choices_desc(store.STORE_TYPE, m.store_type),
credit_type=lambda v, c, m, n: get_choices_desc(store.CREDIT_TYPE, m.credit_type),
status=lambda v, c, m, n: get_choices_desc(store.STORE_STATUS, m.status),
)
def after_model_change(self, form, model, is_created):
super(StoreAdmin, self).after_model_change(form, model, is_created)
Redis.delete(store.ALL_STORE_KEY)
def after_model_delete(self, model):
super(StoreAdmin, self).after_model_delete(model)
Redis.delete(store.ALL_STORE_KEY)
class TaskAdmin(ModelView):
form = TaskForm
can_view_details = True
details_modal = True
column_details_list = ('title', 'description', 'image', 'task_type', 'action', 'activity_id',
'task_platform', 'game_id', 'num', 'product_id', 'product_num')
column_list = ('title', 'description', 'image', 'task_type', 'action', 'task_platform', 'num',
'product_id', 'product_num')
column_labels = dict(title=u'标题', description=u'描述', image=u'图片', task_type=u'任务类型',
action=u'任务条件', game_id=u'游戏ID', num=u'条件数值', product_id=u'奖励物品',
product_num=u'奖励物品数量', task_platform=u'任务平台', activity_id=u'活动ID')
column_formatters = dict(
image=format_image,
task_type=lambda v, c, m, n: get_choices_desc(TASK_TYPE, m.task_type),
action=lambda v, c, m, n: get_choices_desc(TASK_ACTION, m.action),
game_id=format_game,
product_id=lambda v, c, m, n: get_choices_desc(Product.all_products_for_admin(),
m.product_id),
task_platform=lambda v, c, m, n: get_choices_desc(TASK_PLATFORMS, m.task_platform),
)
def create_form(self, obj=None):
form = super(TaskAdmin, self).create_form(obj)
form.product_id.choices = Product.all_products_for_admin()
# aids = [('', u'不限定')]
# aids.extend(ActivityConfig.activity())
# form.activity_id.choices = aids
return form
def edit_form(self, obj=None):
form = super(TaskAdmin, self).edit_form(obj)
form.product_id.choices = Product.all_products_for_admin()
# aids = [('', u'不限定')]
# aids.extend(ActivityConfig.activity())
# form.activity_id.choices = aids
form.task_type.choices = filter(lambda x:x[0] == obj.task_type, TASK_TYPE)
return form
def after_model_change(self, form, model, is_created):
super(TaskAdmin, self).after_model_change(form, model, is_created)
Redis.delete(TASK_KEY)
def after_model_delete(self, model):
super(TaskAdmin, self).after_model_delete(model)
UserTask.delete().where(UserTask.task_id==model.task_id).execute()
Redis.delete(TASK_KEY)
def create_model(self, form):
if form.topest.data:
Task.reset_topest_task()
return super(TaskAdmin, self).create_model(form)
def update_model(self, form, model):
if form.topest.data:
Task.reset_topest_task()
return super(TaskAdmin, self).update_model(form, model)
class WatchLiveTaskItemAdmin(WxModelView):
Model = WatchLiveTaskItem
form = WatchLiveTaskItemForm
can_view_details = True
details_modal = True
column_details_list = ('wlt_id', 'product_id', 'product_num', 'title', 'identity')
column_labels = dict(wlt_id=u'观看直播时长任务ID', product_id=u'物品', product_num=u'物品数量', title=u'商品描述',
identity=u'营销平台奖项ID')
column_formatters = dict(
wlt_id=lambda v, c, m, n: format_model(m, n, WatchLiveTask),
product_id=lambda v, c, m, n: get_choices_desc(Product.all_products_for_admin(), m[n]),
)
def create_form(self, obj=None):
form = super(WatchLiveTaskItemAdmin, self).create_form(obj)
form.wlt_id.choices = WatchLiveTask.all_tasks_for_admin()
form.product_id.choices = Product.all_products_for_admin()
return form
def edit_form(self, obj=None):
form = super(WatchLiveTaskItemAdmin, self).edit_form(obj)
form.wlt_id.choices = WatchLiveTask.all_tasks_for_admin()
form.product_id.choices = Product.all_products_for_admin()
return form
def after_model_change(self, form, model, is_created):
super(WatchLiveTaskItemAdmin, self).after_model_change(form, model, is_created)
self.Model.clear_redis(form.wlt_id.data)
self.Model.clear_redis(model['wlt_id'])
def after_model_delete(self, model):
super(WatchLiveTaskItemAdmin, self).after_model_delete(model)
self.Model.clear_redis(model['wlt_id'])
def format(self):
data = {
'color_id': self.color_id,
'credit_type': self.credit_type,
'credit_value': self.credit_value,
'desc': util.get_choices_desc(BARRAGE_COLOR_RGB, self.color_id)
}
return data
def format(self):
data = {
'gold': self.gold,
'action': self.action,
'desc': util.get_choices_desc(TRADE_ACTION, self.action),
'create_at': util.datetime2timestamp(self.create_at)
}
return data
def all_stores_for_admin(cls):
stores = list(cls.select())
store_list = []
for s in stores:
type_desc = util.get_choices_desc(STORE_TYPE, s.store_type)
value = u'【%s(%s)】%s' % (type_desc, s.store_id, s.title)
store_list.append((s.store_id, value))
return store_list
def format(self):
data = {
'exchange_time': util.datetime2timestamp(self.exchange_time),
'gift_value': self.gift_value,
'exchange_value': self.exchange_value,
'action': self.action,
'desc': util.get_choices_desc(TRADE_ACTION, self.action),
'create_at': util.datetime2timestamp(self.create_at)
}
return data
class StoreItemAdmin(ModelView):
form = StoreItemForm
can_view_details = True
details_modal = True
column_details_list = ('store_id', 'product_id', 'product_num', 'title', 'credit_type',
'credit_value', 'total_num', 'use_num', 'left_num', 'order', 'identity')
column_list = ('store_id', 'product_id', 'product_num', 'credit_type', 'credit_value',
'left_num', 'order', 'identity')
column_labels = dict(store_id=u'商店', product_id=u'物品', product_num=u'物品数量', title=u'商品描述',
credit_type=u'价格类型', credit_value=u'价格数值', total_num=u'总库存',
use_num=u'已用库存', left_num=u'剩余库存', order=u'显示顺序', identity=u'营销平台奖项ID')
column_formatters = dict(
store_id=lambda v, c, m, n: get_choices_desc(store.Store.all_stores_for_admin(),
m.store_id),
product_id=lambda v, c, m, n: get_choices_desc(Product.all_products_for_admin(),
m.product_id),
credit_type=lambda v, c, m, n: get_choices_desc(store.CREDIT_TYPE, m.credit_type),
)
column_filters = ('store_id',)
def create_form(self, obj=None):
form = super(StoreItemAdmin, self).create_form(obj)
form.store_id.choices = store.Store.all_stores_for_admin()
form.product_id.choices = Product.all_products_for_admin()
return form
def edit_form(self, obj=None):
form = super(StoreItemAdmin, self).edit_form(obj)
form.store_id.choices = filter(lambda x: x[0] == obj.store_id, store.Store.all_stores_for_admin())
# form.store_id.choices = store.Store.all_stores_for_admin()
form.product_id.choices = Product.all_products_for_admin()
return form
def after_model_change(self, form, model, is_created):
super(StoreItemAdmin, self).after_model_change(form, model, is_created)
key = store.STORE_ITEM_KEY % ({'store_id': model.store_id})
Redis.delete(key)
def after_model_delete(self, model):
super(StoreItemAdmin, self).after_model_delete(model)
key = store.STORE_ITEM_KEY % ({'store_id': model.store_id})
Redis.delete(key)
class UserOrderAdmin(ModelView):
form = UserOrderForm
can_create = False
can_delete = False
can_view_details = True
details_modal = True
column_details_list = ('order_id', 'user_id', 'item_id', 'store_id', 'store_type',
'campaign_id', 'title', 'product_id', 'product_num', 'status',
'result', 'recid', 'create_at')
column_list = ('order_id', 'user_id', 'title', 'product_num', 'store_id', 'status')
column_labels = dict(order_id=u'订单ID', user_id=u'用户', item_id=u'商品', store_id=u'商店',
store_type=u'商店类型', campaign_id=u'营销平台活动ID', title=u'商品描述',
product_id=u'物品', product_num=u'物品数量', status=u'状态',
result=u'抽奖结果', recid=u'营销平台兑换订单', create_at=u'创建时间')
column_formatters = dict(
store_id=lambda v, c, m, n: get_choices_desc(store.Store.all_stores_for_admin(),
m.store_id),
product_id=lambda v, c, m, n: get_choices_desc(Product.all_products_for_admin(),
m.product_id),
store_type=lambda v, c, m, n: get_choices_desc(store.STORE_TYPE, m.store_type),
status=lambda v, c, m, n: get_choices_desc(store.STATUS, m.status),
user_id=format_user
)
column_filters = (
'user_id',
PeeweeEqualFilter(
column=store.UserOrder.store_id, name='商店',
options=store.Store.all_stores_for_admin()
),
PeeweeEqualFilter(
column=store.UserOrder.status, name='订单状态',
options=store.STATUS
),
PeeweeEqualFilter(
column=store.UserOrder.product_id, name='物品',
options=Product.all_products_for_admin()
),
)
class GroupAdmin(WxModelView):
Model = Group
form = GroupForm
can_view_details = True
details_modal = True
column_details_list = ['_id', 'name', 'gtype', 'memo', 'create_at']
column_list = ('_id', 'name', 'gtype', 'memo')
column_labels = dict(_id=u'组ID',
name=u'组名',
gtype=u'类型',
memo=u'备注',
create_at=u'创建时间')
column_formatters = dict(
gtype=lambda v, c, m, n: util.get_choices_desc(GROUP_TYPE, m['gtype']),
)
column_filters = (
EqualFilter('_id', u'组ID', ObjectId),
EqualFilter('gtype', u'类型', str, GROUP_TYPE),
LikeFilter('name', u'组名'),
)
class ProductAdmin(ModelView):
form = ProductForm
can_view_details = True
details_modal = True
column_details_list = ('product_id', 'product_name', 'product_image', 'product_type',
'recycle_gem_price')
column_list = ('product_id', 'product_name', 'product_image', 'product_type',
'recycle_gem_price')
column_labels = dict(product_id=u'物品ID', product_name=u'名称', product_image=u'图片',
product_type=u'物品类型', recycle_gem_price=u'回购游票价格')
column_formatters = dict(
product_image=format_image,
product_type=lambda v, c, m, n: get_choices_desc(PRODUCT_TYPE, m.product_type),
)
def after_model_change(self, form, model, is_created):
super(ProductAdmin, self).after_model_change(form, model, is_created)
Redis.delete(PRODUCT_KEY)
def after_model_delete(self, model):
super(ProductAdmin, self).after_model_delete(model)
Redis.delete(PRODUCT_KEY)
class WebGameAdmin(WxModelView):
Model = WebGame
form = WebGameForm
can_view_details = True
details_modal = True
column_details_list = [
'_id', 'migu_code', 'name', 'url', 'description', 'categories',
'engine', 'os', 'intro', 'slogan', 'developer', 'cover', 'icon',
'big_icon', 'order', 'status'
]
column_list = ('_id', 'name', 'cover', 'icon', 'big_icon', 'status')
column_labels = dict(_id=u'游戏ID',
migu_code=u'业务代码',
name=u'游戏名',
url=u'访问地址',
description=u'描述',
categories=u'分类',
engine=u'引擎',
intro=u'简介',
slogan=u'标语',
cover=u'封面图片',
os=u'平台',
icon=u'图标',
big_icon=u'大图标',
status=u'状态',
order=u'显示顺序')
column_formatters = dict(
icon=format_image,
big_icon=format_image,
cover=format_image,
status=format_status,
engine=lambda v, c, m, n: get_choices_desc([
(1, u'普通'),
(2, u'laya'),
(3, u'白鹭'),
], m['engine']),
)
column_filters = (
EqualFilter('_id', u'游戏ID', ObjectId),
EqualFilter('status', u'状态', int, [(const.ONLINE, u'在线'),
(const.OFFLINE, u'下线'),
(const.UNDER_TEST, u'测试')]),
EqualFilter('os', u'平台', str, [('android', u'Android'),
('ios', u'IOS')]),
LikeFilter('name', u'游戏名'),
)
# Modal Templates
edit_template = 'edit.html'
"""edit modal template"""
create_template = 'create.html'
"""create modal template"""
def process_form_data(self, data):
return data
def create_model(self, form):
model = super(WebGameAdmin, self).create_model(form)
# 正式环境创建游戏时, 给stage环境也创建一个
import os
env = os.environ.get('WXENV')
if env == 'Production':
from pymongo import MongoClient
from config import Stage
client = MongoClient(Stage.MONGO_HOST, Stage.MONGO_PORT)
stage_db = client[Stage.MONGO_DBNAME]
pk = self.get_pk_value(model)
obj = self.Model.get_one(pk, check_online=False)
obj.status = const.ONLINE
stage_db.web_games.insert_one(obj)
return model
def update_model(self, form, model):
ret = super(WebGameAdmin, self).update_model(form, model)
return ret
def create_form(self, obj=None):
form = super(WebGameAdmin, self).create_form(obj)
return form
def edit_form(self, obj=None):
form = super(WebGameAdmin, self).edit_form(obj)
return form
class FixedBannerAdmin(WxModelView):
Model = FixedBanner
form = FixedBannerForm
column_list = ('name', 'image', 'position', 'os', 'status')
column_labels = dict(
name=u'banner名称',
image=u'banner图片',
url=u"跳转链接",
begin_at=u'开始时间',
expire_at=u'结束时间',
status=u'状态',
login=u'登录要求',
os=u'平台要求',
version_code_mix=u'最低版本要求',
version_code_max=u'最高版本要求',
channels=u'推送渠道',
province=u'推送省份',
position=u'显示位置',
)
column_details_list = ('name', 'image', 'url', 'begin_at', 'expire_at',
'status', 'login', 'os', 'version_code_mix',
'version_code_max', 'channels', 'province',
'position')
can_view_details = True
details_modal = True
column_formatters = dict(
image=format_image,
begin_at=format_timestamp,
expire_at=format_timestamp,
position=lambda v, c, m, n: get_choices_desc(FB_POSITION, m['position']
),
status=lambda v, c, m, n: get_choices_desc(FB_STATUS, m['status']),
)
def create_form(self, obj=None):
form = super(FixedBannerAdmin, self).create_form(obj)
cids = Channels.all_channels_ids()
channels = Channels.get_list(cids)
form.channels.choices = [(c.sign, c.channels_name) for c in channels]
vids = VersionConfig.all_version_ids()
version = VersionConfig.get_list(vids)
form.version_code_mix.choices = [(v.version_code, v.version_name)
for v in version]
form.version_code_max.choices = [(v.version_code, v.version_name)
for v in version]
pids = Province.all_province_ids()
province = Province.get_list(pids)
form.province.choices = [(p.code, ''.join((p.name, p.operators)))
for p in province]
form.group.choices = Group.groups_for_admin()
return form
def edit_form(self, obj=None):
form = super(FixedBannerAdmin, self).edit_form(obj)
cids = Channels.all_channels_ids()
channels = Channels.get_list(cids)
form.channels.choices = [(c.sign, c.channels_name) for c in channels]
vids = VersionConfig.all_version_ids()
version = VersionConfig.get_list(vids)
form.version_code_mix.choices = [(v.version_code, v.version_name)
for v in version]
form.version_code_max.choices = [(v.version_code, v.version_name)
for v in version]
pids = Province.all_province_ids()
province = Province.get_list(pids)
form.province.choices = [(p.code, ''.join((p.name, p.operators)))
for p in province]
form.group.choices = Group.groups_for_admin()
return form
def create_model(self, obj=None):
crash, msg = FixedBanner.check_crash(obj.data)
if crash:
flash(u"创建失败，发现有冲突的记录（%s）！" % msg, 'error')
return False
model = super(FixedBannerAdmin, self).create_model(obj)
return model
def update_model(self, obj=None, model=None, exclude_fields=[]):
crash, msg = FixedBanner.check_crash(obj.data, model['_id'])
if crash:
flash(u"更新失败，发现有冲突的记录（%s）！" % msg, 'error')
return False
model = super(FixedBannerAdmin,
self).update_model(obj, model, exclude_fields)
return model
