def operation_activity_edit(request):
"""运营活动编辑页面"""
# 获取sid
sid = request.REQUEST.get('sid', '')
# 参数
group_servers_dict = groups_servers(request)
operation_activity = eval(
DictDefine.objects.get(
id=constant.operation_activity_type_id_dict).json_dict)
if sid:
model = OperationActivity.objects.get(sid=sid)
model.activityId = str(model.activityId) # 用于模版语法中活动类型判等
select_server_ids = eval(model.server) # 用于勾选服务器
# 返回模版与参数
return render_to_response('game/operation_activity_edit.html', locals())
def operation_activity_copy(request):
"""运营活动复制"""
# 获取参数
sid = request.REQUEST.get('sid')
# 获取对应模型
model = OperationActivity.objects.get(sid=sid)
# 参数
model.sid = '' # 由于模版会根据sid判断是否新建，因此需要先把sid清空
model.status = 0 # 由于模版会根据状态判断有没有保存按钮，因此需要先把状态设为未审核
model.activityId = str(model.activityId) # 用于模版语法中活动类型判等
select_server_ids = eval(model.server) # 用于勾选服务器
group_servers_dict = groups_servers(request)
operation_activity = eval(
DictDefine.objects.get(
id=constant.operation_activity_type_id_dict).json_dict)
# 返回模版与参数
return render_to_response('game/operation_activity_edit.html', locals())
def query_view(request,
query_name='',
query_model=None,
is_query_do=False,
list_data_handle=False,
template='query/query_view.html'):
'''查询视图,request 传入
@param query_name:查询名称
@param is_query_do: 是否执行查询
'''
now = datetime.datetime.now()
_g = request.REQUEST.get
_gl = request.REQUEST.getlist
query_name = query_name or _g('query_name', '') or _g('name', '')
print 'NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN', query_name
query_id = int(_g('query_id', '') or _g('qid', '') or 0)
# 不传id则使用查询名
if query_id:
the_query = Query.objects.get(id=query_id)
elif query_name:
the_query = Query.objects.using('read').get(name=query_name)
elif query_model:
the_query = query_model
else:
return HttpResponse('没有 ID[%s] 或者 [%s] 的查询' % (query_id, query_name))
params = dict(request.GET)
params.update(dict(request.POST)) # 必须为POST
# print params
log_def = the_query.log_def
query_analysis = QueryAnalysis(the_query, params)
is_center_query = the_query.is_center_query
is_export = _g('is_export', 'False') == 'true'
if is_export: # 导出
return query_export_do(request, query_analysis)
if is_query_do or request.method == 'POST' or request.REQUEST.get(
'query_do') or request.GET.get('template', ''):
return query_do(request,
query_analysis,
list_data_handle=list_data_handle)
same_log_key_query_list = Query.objects.filter(
log_key=the_query.log_key) # 查询的表定义
field_configs = SortedDict()
conditions_configs = []
for cloumn in the_query.selects:
field_config_item = the_query.field_config.get(cloumn, {})
field_configs[cloumn] = field_config_item
for k in the_query.field_config.keys():
field_config_item = the_query.field_config[k]
if field_config_item.get('single', ''):
default_value = DictDefine.get_dict_for_key(
field_config_item.get('dict', ''))
else:
default_value = params.get(field_config_item.get('name', ''),
[''])[0]
field_config_item['value'] = default_value
order_num = int(field_config_item.get('order_num', 0) or 99)
conditions_configs.append((k, field_config_item, order_num))
conditions_configs.sort(key=lambda x: x[2])
sd = request.REQUEST.get('sd', '') or now.strftime('%Y-%m-%d 00:00:00')
ed = request.REQUEST.get('ed', '') or now.strftime('%Y-%m-%d 23:59:59')
has_sd = query_analysis.has_mark('sd')
has_ed = query_analysis.has_mark('ed')
sdate = request.REQUEST.get('sdate',
'') or now.strftime('%Y-%m-%d 00:00:00')
edate = request.REQUEST.get('edate',
'') or now.strftime('%Y-%m-%d 23:59:59')
has_sdate = query_analysis.has_mark('sdate')
has_edate = query_analysis.has_mark('edate')
has_channel = query_analysis.has_mark(
'channel_id') or query_analysis.has_mark('channel_ids')
has_server = query_analysis.has_mark(
'server_id') or query_analysis.has_mark('server_ids')
has_server = has_server or not is_center_query
has_neibuhao = query_analysis.has_mark('neibuhao')
has_platform = query_analysis.has_mark(
'platform_id') or query_analysis.has_mark('platform_ids')
has_conditions = query_analysis.has_conditions()
if request.admin.is_agent and not has_channel:
return render_to_response('block.html', {"err_msg": "'此查询非法!'"})
plugin_templates = []
if the_query.template_name:
for template_name in the_query.template_name.split(','):
if template_name.strip():
if template_name == "邮件列表":
dj = json.dumps(
eval(DictValue.objects.get(dict_id=88).json_dict))
plugin_templates.append('query/plugins/%s.html' %
template_name)
if has_server:
# group_servers_dict = get_group_servers_dict(request)
group_servers_dict = groups_servers(request)
select_server_ids = [
int(sid) for sid in request.REQUEST.getlist('sid')
if str(sid).isdigit()
]
if has_channel:
group_channels_dict = get_group_channels_dict()
if has_platform:
platforms = request.admin.get_resource('platform')
server_id = int(request.REQUEST.get('server_id', 0))
return render_to_response(template, locals())
model.create_time = datetime.datetime.now()
model.status = 0
if msg.get('on_time', ''):
model.order_time = msg['on_time']
model.time_status = 1
model.save(using='write')
_r['code'] = 0
err_msg = "成功保存"
except Exception, e:
traceback.print_exc()
err_msg = trace_msg()
_r['msg'] = err_msg
return HttpResponse(json.dumps(_r))
# group_servers_dict = get_group_servers_dict(request)
group_servers_dict = groups_servers(request)
# 资源类型
award_type_dict = DictDefine.objects.get(
id=constant.award_type_id).json_dict
# 下级列表
key_num_list = eval(award_type_dict).keys()
subordinate_list = '['
subordinate_list_dict = eval(
DictDefine.objects.get(id=constant.subordinate_list_id).json_dict)
for i in key_num_list:
dic = '{'
for one in subordinate_list_dict:
if i == one.split('.')[0]:
dic += '"' + one.split(
def batch_edit(request):
model_id = request.GET.get('id', 0)
group_id = int(request.REQUEST.get('group_id', '') or 0)
card_id = request.GET.get('card_id', 0)
is_copy = request.GET.get('is_copy', '')
# group_servers_dict = get_group_servers_dict(request,group_id)
group_servers_dict = groups_servers(request)
# agent_channels_dict = get_agent_channels_dict(request)
group_channels_dict = get_group_channels_dict()
query_server = []
query_channel = []
model_id = int(model_id)
the_key = ''
if model_id > 0:
model = CardBatch.objects.using('card').get(id=model_id)
select_server_ids = model.get_server_ids()
select_channel_ids = model.get_channels_ids()
prize = model.prize
else:
try:
conn = connections['card']
cursor = conn.cursor()
sql = "SELECT SUBSTR(`table_name`,7) FROM INFORMATION_SCHEMA.`TABLES` WHERE `table_schema` = 'fytx2_card' AND `table_name` REGEXP '^cards_[[:lower:]]{3}$' ORDER BY `table_name` DESC LIMIT 1"
cursor.execute(sql)
count = cursor.fetchone()
the_key = count[0]
except:
pass
now = datetime.datetime.now()
model = CardBatch()
model.id = model_id
model.limit_count = 1
print '7' * 40
print the_key
model.make_card_key(the_key)
model.start_time = "2000-01-01 00:00:00"
model.end_time = (
now + datetime.timedelta(days=90)).strftime("%Y-%m-%d 00:00:00")
if is_copy and card_id > 0:
card_model = CardBatch.objects.using('card').get(id=card_id)
select_server_ids = card_model.get_server_ids()
select_channel_ids = card_model.get_channels_ids()
prize = card_model.prize
is_dialog = request.REQUEST.get('is_dialog', '')
last_url = '/card/batch/?status=1'
# 道具、资源列表
property_dict = DictDefine.objects.get(
id=constant.property_id_dict).json_dict
resource_dict = DictDefine.objects.get(
id=constant.resource_id_dict).json_dict
return render_to_response('card/batch_edit.html', locals())
def server_merge(request, auto_merge=False):
if request.method == 'POST':
if auto_merge:
# import pdb;pdb.set_trace()
master_server_id = request.POST.get("master_server_id", '')
merge_server_ids = request.POST.get("server_id")
close_time = ""
else:
master_server_id = request.REQUEST.get('master_server_id', '')
merge_server_ids = request.REQUEST.getlist('server_id')
close_time = request.REQUEST.get('close_time', '')
err_msg = ''
if not master_server_id:
err_msg = '母服错误'
if not merge_server_ids:
err_msg = '没有勾选子服!'
try:
if not err_msg:
master_server = Server.objects.get(id=master_server_id)
master_server_db_config = master_server.get_log_db_config()
master_server_confog = master_server.get_json_data()
porxyport = master_server_confog.get('porxyport',
'') # 腾讯的代理端口
host = master_server_db_config.get('host', '')
port = master_server_db_config.get('port', 3306)
user = master_server_db_config.get('user', '')
password = master_server_db_config.get('password', '')
mongo_port = master_server_db_config.get('mongo_port', 27017)
gm_port = master_server_db_config.get('gm_port', '')
db_name = master_server_db_config.get('db', '')
report_url = master_server.report_url
game_addr = master_server.game_addr
game_port = master_server.game_port
game_db_addr_port = master_server.game_db_addr_port
game_db_name = master_server.game_db_name
game_db_user = master_server.game_db_user
game_db_password = master_server.game_db_password
merge_servers = Server.objects.filter(id__in=merge_server_ids)
# # 生成json文件
# server_merge_json(master_server, merge_servers)
mastrer_str = '母服 [%s]' % master_server.name
err_msg = mastrer_str + '\n'
for child_server in merge_servers:
if child_server.id == master_server.id:
continue
try:
source_model = copy.copy(child_server)
child_server.report_url = report_url
child_server.game_addr = game_addr
child_server.game_port = game_port
child_server.game_db_addr_port = game_db_addr_port
child_server.game_db_name = game_db_name
child_server.game_db_user = game_db_user
child_server.game_db_password = game_db_password
child_server_db_config = child_server.get_log_db_config(
)
child_server_db_config['gm_port'] = gm_port
child_server_db_config['host'] = host
child_server_db_config['port'] = port
child_server_db_config['user'] = user
child_server_db_config['password'] = password
child_server_db_config['mongo_port'] = mongo_port
child_server_db_config['close_time'] = close_time
child_server_db_config['db'] = db_name
child_server.set_log_db_config(child_server_db_config)
child_server_config = child_server.get_json_data()
child_server_config[
'master_server_id'] = master_server.id
if porxyport: # 腾讯需要的设置
child_server_config['porxyport'] = int(porxyport)
child_server.set_json_data(child_server_config)
if '母服 ' in child_server.remark:
child_server.remark = re.sub(
'母服 \[.*\]', mastrer_str, child_server.remark)
else:
child_server.remark += mastrer_str
save_server_log(child_server.id, False, request,
source_model, child_server)
child_server.save()
err_msg += '%s 保存成功!\n' % child_server.name
except:
err_msg += '%s 保存失败 %s!\n' % (child_server.name,
trace_msg())
except:
err_msg = trace_msg()
if auto_merge:
if "成功" in err_msg:
return {"result": "success", "msg": err_msg}
return {"result": "fail", "msg": err_msg}
return render_to_response('feedback.html',
err_msg.replace('\n', '<br>'))
# group_servers_dict = get_group_servers_dict(request)
group_servers_dict = groups_servers(request)
list_server = Server.objects.all()
return render_to_response('server/server_merge.html', locals())
def roll_broadcast(request, template='game/roll_broadcast.html'):
'''滚动公告
'''
server_id = int(request.REQUEST.get('server_id', '') or 0)
# group_servers_dict = get_group_servers_dict(request)
group_servers_dict = groups_servers(request)
select_server_ids = [server_id]
try:
if server_id:
gmp = GMProtocol(server_id)
# server_time = gmp.query_server_time()[0]
if request.method == 'POST':
json_msg = request.REQUEST.get('msg', '')
msg = json.loads(json_msg)
_r = {"code": -1, "msg": ""}
if request.REQUEST.get('req_type', '') == 'roll_broadcast_del':
result = gmp.roll_broadcast_del(msg)
else:
# 编写notice.json
content = write_notice_json(msg, server_id)
path = os.path.abspath(
os.path.join(
os.path.abspath(os.path.join(
STATIC_PATH, 'server')), 'notice.json'))
with open(path, 'w') as f:
f.write(content)
msg["content"] = msg["content"].replace("<br />", "")
result = gmp.roll_broadcast_set(msg)
_r['code'] = result
_r['msg'] = gmp.rsp_map.get(result, result)
gmp.save_log(request.admin.id,
gmp.req_type,
_r['code'],
remark1='remark',
remark2=json_msg)
return HttpResponse(json.dumps(_r))
else:
roll_broadcasts = gmp.roll_broadcast_query()
server_model = Server.objects.get(id=server_id)
else:
# # 构建服务器id与名字的字典
# servers = Server.objects.all()
# servers_dict = dict()
# for server in servers:
# servers_dict[int(server.id)] = server.name
the_user = request.admin
server_list = the_user.get_resource("server").all()
# 返回所有正在滚动的公告
roll_broadcasts = []
# for g,servers in group_servers_dict.items():
# for s in servers:
# for s in server_list:
# try:
# if s.id == -1:
# continue
# gmp = GMProtocol(s.id)
# result = gmp.roll_broadcast_query()
# if result:
# result[1]['serverId'] = s.id
# result[1]['serverName'] = s.name
# roll_broadcasts.extend(result)
# except Exception:
# continue
p = ThreadP(30)
for s in server_list:
thread = p.get_thread()
t = thread(target=threadp, args=(s, p, roll_broadcasts))
t.start()
# gmp = GMProtocol(7)
# roll_broadcasts = gmp.roll_broadcast_query()
# print roll_broadcasts
# if roll_broadcasts:
# roll_broadcasts[0]['serverId'] = 7
# roll_broadcasts[0]['serverName'] = 'test'
# server_model = Server.objects.get(id=7)
except:
err_msg = trace_msg()
return render_to_response(template, locals())