def _calc_query(self, data, req, timer):
if not data.is_valid():
if not console_business.init_console(data, timer.now):
raise Exception("Init console failed")
transfer = transfer_business.get_transfer_by_user_id(data, req.user_id)
if transfer == None:
transfer = TransferInfo.create(data.id, req.user_id,
TransferMatcher.MAX_RANK, False)
data.transfer_list.add(transfer)
top20 = TransferMatcher().get_top20(data)
match = TransferMatcher().match(data, transfer)
behind5 = TransferMatcher().get_behind5(data, transfer)
res = internal_pb2.InternalQueryTransferRes()
res.status = 0
pack.pack_transfer_info(transfer, res.self,
internal_pb2.InternalTransferInfo.SELF)
for t in top20:
pack.pack_transfer_info(t, res.top20.add(),
internal_pb2.InternalTransferInfo.TOP)
for m in match:
pack.pack_transfer_info(m, res.match.add(),
internal_pb2.InternalTransferInfo.MATCH)
for b in behind5:
pack.pack_transfer_info(b, res.behind5.add(),
internal_pb2.InternalTransferInfo.BEHIND)
defer = DataBase().commit(data)
defer.addCallback(self._query_succeed, req, res, timer)
return defer
def _calc_exchange(self, data, req, timer):
if not data.is_valid():
if not console_business.init_console(data, timer.now):
raise Exception("Init console failed")
res = internal_pb2.InternalExchangeTransferRes()
res.status = 0
transfer = transfer_business.get_transfer_by_user_id(data, req.user_id)
assert transfer != None
target_transfer = transfer_business.get_transfer_by_user_id(
data, req.target_user_id)
assert target_transfer != None
res.self_rank = transfer.rank
res.rival_rank = target_transfer.rank
if target_transfer.rank < transfer.rank and req.exchange:
#if target_transfer.is_robot:
# transfer.rank = target_transfer.rank
# data.transfer_list.delete(target_transfer.id)
#else:
# target_transfer.rank, transfer.rank = transfer.rank, target_transfer.rank
target_transfer.rank, transfer.rank = transfer.rank, target_transfer.rank
defer = DataBase().commit(data)
defer.addCallback(self._exchange_succeed, req, res, timer)
return defer
def _calc_modify(self, data, req, timer):
"""修改逻辑
"""
if not data.is_valid():
if not console_business.init_console(data, timer.now):
raise Exception("Init console failed")
worldboss = data.worldboss.get()
if req.HasField("total_soldier_num"):
worldboss.total_soldier_num = req.total_soldier_num
if req.HasField("current_soldier_num"):
worldboss.current_soldier_num = req.current_soldier_num
if req.HasField("kill_user_name"):
worldboss.kill_user_name = req.kill_user_name
if req.HasField("kill_user_id"):
worldboss.kill_user_id = req.kill_user_id
res = boss_pb2.ModifyWorldBossRes()
res.status = 0
defer = DataBase().commit(data)
defer.addCallback(self._modify_succeed, req, res, timer)
return defer
def _calc_query_anneal_record(self, data, req, timer):
"""查询逻辑
"""
if not data.is_valid():
if not console_business.init_console(data, timer.now):
raise Exception("Init console failed")
record = anneal_record_business.query_anneal_record(data, req.floor)
res = anneal_pb2.QueryAnnealRecordRes()
res.status = 0
record_message = res.records.add()
record_message.type = 1
record_message.name = record.get_readable_first_name()
record_message.level = record.first_level
record_message.icon_id = record.first_icon_id
record_message.finish_passed_time = timer.now - record.first_finished_time
record_message = res.records.add()
record_message.type = 2
record_message.name = record.get_readable_fast_name()
record_message.level = record.fast_level
record_message.icon_id = record.fast_icon_id
record_message.finish_passed_time = timer.now - record.fast_finished_time
record_message.cost_time = record.fast_cost_time
defer = DataBase().commit(data)
defer.addCallback(self._query_anneal_record_succeed, req, res, timer)
return defer
def _calc_update_country(self, data, req, timer):
"""
"""
if not data.is_valid():
if not console_business.init_console(data, timer.now):
raise Exception("Init console failed")
country = data.country.get()
if req.old_country == 1:
country.reduce_wei_weight()
elif req.old_country == 2:
country.reduce_shu_weight()
else:
country.reduce_wu_weight()
if req.new_country == 1:
country.add_wei_weight()
elif req.new_country == 2:
country.add_shu_weight()
else:
country.add_wu_weight()
res = monarch_pb2.UpdateCountryRes()
res.status = 0
defer = DataBase().commit(data)
defer.addCallback(self._update_country_succeed, req, res, timer)
return defer
def _calc_delete(self, data, req, timer):
"""删除广播逻辑
"""
if not data.is_valid():
if not console_business.init_console(data, timer.now):
raise Exception("Init console failed")
if not broadcast_business.delete_broadcast(data, timer.now, req.ids):
raise Exception("Delete broadcast failed")
defer = DataBase().commit(data)
defer.addCallback(self._delete_succeed, req, timer)
return defer
def _calc_query(self, data, req, timer):
"""查询逻辑
"""
if not data.is_valid():
if not console_business.init_console(data, timer.now):
raise Exception("Init console failed")
worldboss = data.worldboss.get()
arise_time = 0
start_time = 0
end_time = 0
boss_id = 0
total_soldier_num = 0
kills_addition = 0
user_id = 0
user_name = ''
if req.HasField("arise_time"):
arise_time = req.arise_time
if req.HasField("start_time"):
start_time = req.start_time
if req.HasField("end_time"):
end_time = req.end_time
if req.HasField("boss_id"):
boss_id = req.boss_id
if req.HasField("total_soldier_num"):
total_soldier_num = req.total_soldier_num
if req.HasField("kills_addition"):
kills_addition = req.kills_addition
if req.HasField("user_id"):
user_id = req.user_id
if req.HasField("user_name"):
user_name = req.user_name
if not worldboss_business.update_worldboss(
data, timer.now, arise_time, start_time, end_time, boss_id,
kills_addition, total_soldier_num, user_id, user_name):
raise Exception("Update worldboss failed")
res = boss_pb2.QueryCommonWorldBossRes()
res.status = 0
res.total_soldier_num = worldboss.get_total_soldier_num()
res.current_soldier_num = worldboss.get_current_soldier_num()
if worldboss.is_dead():
res.kill_user_name = worldboss.kill_user_name
res.kill_user_id = worldboss.kill_user_id
defer = DataBase().commit(data)
defer.addCallback(self._query_succeed, req, res, timer)
return defer
def _calc_add(self, data, req, timer):
"""添加广播逻辑
"""
if not data.is_valid():
if not console_business.init_console(data, timer.now):
raise Exception("Init console failed")
if not broadcast_business.add_broadcast(data, timer.now, req.mode_id,
req.priority, req.life_time,
req.content):
raise Exception("Add broadcast failed")
defer = DataBase().commit(data)
defer.addCallback(self._add_succeed, req, timer)
return defer
def _calc_update_anneal_record(self, data, req, timer):
"""更新逻辑
"""
if not data.is_valid():
if not console_business.init_console(data, timer.now):
raise Exception("Init console failed")
for record in req.records:
if not anneal_record_business.update_anneal_record(
data, req.floor, record.type, record.name, record.level,
record.icon_id, record.finish_passed_time,
record.cost_time, timer.now):
raise Exception("Update anneal record failed")
defer = DataBase().commit(data)
defer.addCallback(self._update_anneal_record_succeed, req, timer)
return defer
def _calc_query(self, data, req, timer):
if not data.is_valid():
if not console_business.init_console(data, timer.now):
raise Exception("Init console failed")
exchange_business.refresh_exchange(data, timer.now)
exchange = data.exchange.get()
res = exchange_pb2.QueryExchangeProportionRes()
res.status = 0
res.money2food_exchange_ratio = exchange.money_proportion
res.food2money_exchange_ratio = exchange.food_proportion
res.next_fresh_ratio_time = \
exchange.last_refresh_time + CommonExchangeInfo.refresh_time() - timer.now
defer = DataBase().commit(data)
defer.addCallback(self._query_succeed, req, res, timer)
return defer
def _calc_add(self, data, req, common_id, timer):
cat_list = data.cat_list.get_all()
index = 1
if len(cat_list) == 0:
index = 1
else:
index = cat_list[-1].index + 1
logger.notice("index =%s" % index)
if not data.is_valid():
if not console_business.init_console(data, timer.now):
raise Exception("Init console failed")
if not cat_business.add_cat(data, common_id, req.user_id, req.name,
req.gold, index):
raise Exception("Add cat failed")
logger.notice("===============1")
defer = DataBase().commit(data)
logger.notice("===============2")
defer.addCallback(self._add_succeed, req, timer)
return defer
def _calc_query(self, data, req, timer):
"""查询广播逻辑
"""
if not data.is_valid():
if not console_business.init_console(data, timer.now):
raise Exception("Init console failed")
logger.notice("1111111111")
broadcast_list = broadcast_business.query_broadcast(data, timer.now)
logger.notice("BROAD")
res = broadcast_pb2.QueryBroadcastInfoRes()
res.status = 0
for broadcast in broadcast_list:
record = res.records.add()
record.mode_id = broadcast.mode_id
record.passed_time = 0 #to delete in next version
record.content = broadcast.get_readable_content()
record.id = broadcast.id
defer = DataBase().commit(data)
defer.addCallback(self._query_succeed, req, res, timer)
return defer
def _calc_query_suggested_country(self, data, req, timer):
"""
"""
if not data.is_valid():
if not console_business.init_console(data, timer.now):
raise Exception("Init console failed")
country = data.country.get()
suggested_country = country.get_country_of_least_weight()
reward_gold = int(
float(data_loader.
OtherBasicInfo_dict["reward_gold_for_choose_country"].value))
res = monarch_pb2.QuerySuggestedCountryRes()
res.status = 0
res.country = suggested_country
res.reward_gold = reward_gold
defer = DataBase().commit(data)
defer.addCallback(self._query_suggested_country_succeed, req, res,
timer)
return defer
