def putRaidHelpList(self, do_execute=True, limit=None, offset=0):
"""救援依頼一覧を埋め込む.
"""
limit = limit or Defines.RAIDHELP_LIST_MAXLENGTH
v_player = self.getViewerPlayer()
model_mgr = self.getModelMgr()
raidhelpidlist = BackendApi.get_raidhelpidlist(model_mgr, v_player.id, limit=limit, offset=offset, using=settings.DB_READONLY)
raidhelplist = BackendApi.get_raidhelplist(model_mgr, raidhelpidlist, using=settings.DB_READONLY)
if len(raidhelplist) == 0:
self.html_param['raidhelplist'] = []
return None
raididlist = []
oid_set = set()
for raidhelp in raidhelplist:
raididlist.append(raidhelp.raidid)
oid_set.add(raidhelp.fromid)
o_playerlist = BackendApi.get_players(self, oid_set, [], using=settings.DB_READONLY, model_mgr=model_mgr)
o_playerdict = dict([(o_player.id, o_player) for o_player in o_playerlist])
persons = BackendApi.get_dmmplayers(self, o_playerlist, using=settings.DB_READONLY, do_execute=do_execute)
raidid_items = dict([(raidhelp.raidid, raidhelp) for raidhelp in raidhelplist])
raididlist = raidid_items.keys()
happeningraidset_dict = dict([(model.id, model) for model in BackendApi.get_happeningraidset_list(model_mgr, raididlist, using=settings.DB_READONLY) if model.happening.happening.is_active()])
leaders = BackendApi.get_leaders(oid_set, model_mgr, using=settings.DB_READONLY)
endidlist = list(set(raididlist) - set(happeningraidset_dict.keys()))
if endidlist:
BackendApi.remove_raidhelpid_list([raidid_items[endid] for endid in endidlist])
self.addlog(u'remove_raidhelpid_list:%s' % endidlist)
def cb():
now = OSAUtil.get_now()
obj_raidlist = []
for raidhelp in raidhelplist:
if happeningraidset_dict.has_key(raidhelp.raidid):
happeningraidset = happeningraidset_dict[raidhelp.raidid]
happeningset = happeningraidset.happening
raidboss = happeningraidset.raidboss
if happeningset.happening.event:
eventraidmaster = BackendApi.get_eventraidmaster_by_modeleventvalue(model_mgr, happeningset.happening.event, raidboss.master.id, using=settings.DB_READONLY)
raidboss.setEventRaidMaster(eventraidmaster)
o_person = None
o_player = o_playerdict.get(raidhelp.fromid)
if o_player:
o_person = persons.get(o_player.dmmid)
obj_raid = Objects.raid(self, raidboss, o_person, leaders.get(raidhelp.fromid))
obj_raid['timelimit'] = Objects.timelimit(happeningset.happening.etime, now)
obj_raidlist.append(obj_raid)
self.html_param['raidhelplist'] = obj_raidlist
if do_execute:
cb()
return None
else:
return cb
def check(self):
model_mgr = ModelRequestMgr()
# 確認キー.
playerrequest = BackendApi.get_model(model_mgr, PlayerRequest,
self.__player0.id)
if self.__player0.req_confirmkey == playerrequest.req_confirmkey:
raise AppTestError(u'確認キーが更新されていない')
elif self.__player0.req_confirmkey != playerrequest.req_alreadykey:
raise AppTestError(u'確認済みのキーが更新されていない')
# ハプニング.
happeningset = BackendApi.get_happening(model_mgr, self.__raid.id)
if happeningset.happening.state != Defines.HappeningState.END:
raise AppTestError(u'状態が正しくない')
# ダメージレコード.
raidboss = BackendApi.get_raid(model_mgr, self.__raid.id)
record = raidboss.getDamageRecord(self.__player0.id)
if record.damage == 0 or record.damage_cnt == 0:
raise AppTestError(u'ダメージが記録されていない')
# ダメージ.
record_pre = self.__raid.getDamageRecord(self.__player0.id)
if (self.__raid.raid.hp -
(record.damage - record_pre.damage)) != raidboss.raid.hp:
raise AppTestError(u'ダメージが正しくない')
# 秘宝.
playertreasure0 = PlayerTreasure.getByKey(self.__player0.id)
if playertreasure0.cabaretking != self.__raid.get_cabaretking():
raise AppTestError(u'キャバ王の秘宝が付与されていない')
# 報酬.
present_num0 = BackendApi.get_present_num(self.__player0.id)
if self.__present_num0 == present_num0:
raise AppTestError(u'発見者に報酬が付与されていない')
# 短冊.
def check_tanzaku_num(tanzaku_data_pre, is_lovetime):
uid = tanzaku_data_pre.uid
ownername = u'発見者' if self.__player0.id == uid else '救援者'
tanzaku_data_post = BackendApi.get_scoutevent_tanzakucastdata(
model_mgr, uid, self.__eventmaster.id)
if tanzaku_data_post is None:
raise AppTestError(u'{}の短冊情報が消えている'.format(ownername))
sep = '' if self.__player0.id == uid else '_help'
tanzakuup = self.__eventmaster.lovetime_tanzakuup if is_lovetime else 0
tanzaku_number = getattr(self.__scouteventraidmaster,
'tanzaku{}_number'.format(sep))
tanzaku_randmin = getattr(
self.__scouteventraidmaster,
'tanzaku{}_randmin'.format(sep)) * (100 + tanzakuup) / 100
tanzaku_randmax = getattr(
self.__scouteventraidmaster,
'tanzaku{}_randmax'.format(sep)) * (100 + tanzakuup) / 100
tanzaku_diff = tanzaku_data_post.get_tanzaku(
tanzaku_number) - tanzaku_data_pre.get_tanzaku(tanzaku_number)
if not (tanzaku_randmin <= tanzaku_diff <= tanzaku_randmax):
raise AppTestError(u'{}の短冊の増加量が想定外です'.format(ownername))
check_tanzaku_num(self.__tanzaku_data0,
self.__scoutevent_playdata.is_lovetime())
if Defines.RAID_PRIZE_DISTRIBUTION_OUTSIDE:
queue = RaidPrizeDistributeQueue.getValues(
filters={'raidid': self.__raid.id})
if queue is None:
raise AppTestError(u'報酬配布用のキューが作成されていない')
def write(queue, happening, raidboss, help_prizelist):
model_mgr = ModelRequestMgr()
BackendApi.tr_distribute_raid(model_mgr, queue, happening,
raidboss, help_prizelist)
model_mgr.write_all()
model_mgr.write_end()
help_prizelist = BackendApi.get_prizelist(
model_mgr, raidboss.master.helpprizes)
write(queue,
BackendApi.get_happening(model_mgr, raidboss.id).happening,
raidboss, help_prizelist)
# 救援者の報酬を確認.
present_num1 = BackendApi.get_present_num(self.__player1.id)
if self.__present_num1 == present_num1:
raise AppTestError(u'救援者に報酬が付与されていない')
playertreasure1 = PlayerTreasure.getByKey(self.__player1.id)
if 0 < self.__raid.get_demiworld(
) and playertreasure1.demiworld != self.__raid.get_demiworld():
raise AppTestError(u'裏社会の秘宝が付与されていない')
# 短冊.
check_tanzaku_num(self.__tanzaku_data1, False)
def process(self):
v_player = self.getViewerPlayer()
model_mgr = self.getModelMgr()
# 合成結果.
compositiondata = BackendApi.get_compositiondata(
model_mgr, v_player.id, using=settings.DB_READONLY)
# ベースカード.
basecardset = BackendApi.get_cards([compositiondata.result_baseid],
model_mgr,
using=settings.DB_READONLY)
if not basecardset or basecardset[0].card.mid != compositiondata.mid:
if settings_sub.IS_LOCAL:
raise CabaretError(u'教育したキャストが見つかりません.')
url = UrlMaker.composition()
self.appRedirect(self.makeAppLinkUrlRedirect(url))
return
basecardset = basecardset[0]
self.html_param['basecard_post'] = Objects.card(self, basecardset)
compositiondata.set_to_card(basecardset.card)
self.html_param['basecard_pre'] = Objects.card(self, basecardset)
# 素材カード.
materialcardsetlist = BackendApi.get_cards(
compositiondata.result_materialidlist,
model_mgr,
using=settings.DB_READONLY,
deleted=True)
self.html_param['cardlist'] = [
Objects.card(self, cardset) for cardset in materialcardsetlist
]
# 経験値とレベル.
self.html_param['exp'] = compositiondata.result_exp
self.html_param['levelup'] = compositiondata.result_lvup
# お金.
self.html_param['cost'] = compositiondata.result_cost_gold
# スキル.
self.html_param['skilllevelup'] = compositiondata.result_skilllvup
# 成功 or 大成功.
self.html_param[
'is_great_success'] = compositiondata.result_flag_great_success
# 上昇値.
level_pre = compositiondata.result_lvpre
level_add = compositiondata.result_lvup
power_add = 0
if 0 < level_add:
basemaster = basecardset.master
pow_pre = CardUtil.calcPower(basemaster.gtype,
basemaster.basepower,
basemaster.maxpower, level_pre,
basemaster.maxlevel,
basecardset.card.takeover)
pow_post = CardUtil.calcPower(basemaster.gtype,
basemaster.basepower,
basemaster.maxpower,
level_pre + level_add,
basemaster.maxlevel,
basecardset.card.takeover)
power_add = pow_post - pow_pre
self.html_param['power_add'] = power_add
self.html_param['level_add'] = level_add
self.html_param['skilllevel_add'] = compositiondata.result_skilllvup
# 続けて合成のURL.
url = UrlMaker.compositionmaterial(basecardset.id)
self.html_param['url_continue'] = self.makeAppLinkUrl(url)
self.writeAppHtml('composition/complete')
def handle(self, *args, **options):
print '================================'
print 'reload_gachaplayerconsumepoint'
print '================================'
model_mgr = ModelRequestMgr()
# メンテモードでやって欲しい.
appconfig = BackendApi.get_appconfig(model_mgr, using=backup_db)
if not settings_sub.IS_DEV and not appconfig.is_maintenance():
print u'メンテナンスモードにしてください'
return
# ユーザIDの最大値.
uid_max = PlayerHappening.max_value('id', 0, using=backup_db)
qs_field = "iid,SUM(price*inum)"
qs_where = "WHERE uid=:1 and state=%s group by iid" % PaymentData.Status.COMPLETED
for uid in xrange(1, uid_max + 1):
# 課金レコードを集計.
gacha_point_table = dict([(int(iid), int(point))
for iid, point in GachaPaymentEntry.sql(
qs_where, uid).fetch(qs_field)])
shop_point_table = dict([(int(iid), int(point))
for iid, point in ShopPaymentEntry.sql(
qs_where, uid).fetch(qs_field)])
gacha_point = sum(gacha_point_table.values())
shop_point = sum(shop_point_table.values())
total = gacha_point + shop_point
if total < 1:
print '%s...zero' % uid
continue
elif PlayerHappening.getByKey(uid, using=backup_db) is None:
print '%s...none' % uid
continue
# プレイヤーデータに保存.
def tr(uid, gacha_point_table, total):
model_mgr = ModelRequestMgr()
if gacha_point_table:
for iid, point in gacha_point_table.items():
if point < 1:
continue
def forUpdateGacha(model, inserted, point):
model.point = point
model_mgr.add_forupdate_task(
GachaConsumePoint,
GachaConsumePoint.makeID(uid, iid), forUpdateGacha,
point)
# 生涯課金額.
def forUpdatePlayerConsumePoint(model, inserted, total):
model.point_total = total
model_mgr.add_forupdate_task(PlayerConsumePoint, uid,
forUpdatePlayerConsumePoint,
total)
model_mgr.write_all()
return model_mgr
db_util.run_in_transaction(tr, uid, gacha_point_table,
total).write_end()
print '%s...g:%s,s:%s' % (uid, gacha_point, shop_point)
print '================================'
print 'all done...'
def setUp(self):
model_mgr = ModelRequestMgr()
# Player.
self.__player0 = self.create_dummy(DummyType.PLAYER)
self.__player1 = self.create_dummy(DummyType.PLAYER)
# 報酬.
itemmaster = self.create_dummy(DummyType.ITEM_MASTER)
prize = self.create_dummy(DummyType.PRIZE_MASTER,
gold=100,
gachapt=10,
item=itemmaster)
# イベントマスター.
eventmaster = self.create_dummy(DummyType.SCOUT_EVENT_MASTER,
lovetime_tanzakuup=100)
self.__eventmaster = eventmaster
# ステージマスター.
stagemaster = self.create_dummy(DummyType.SCOUT_EVENT_STAGE_MASTER,
eventid=eventmaster.id,
stage=1)
self.__stagemaster = stagemaster
# OPを閲覧済みに.
flagrecord = self.create_dummy(DummyType.SCOUT_EVENT_FLAGS,
self.__player0.id,
self.__eventmaster.id,
OSAUtil.get_now())
self.__flagrecord = flagrecord
# 逢引ラブタイム状態にする.
playdata = self.create_dummy(DummyType.SCOUT_EVENT_PLAY_DATA,
self.__player0.id,
self.__eventmaster.id,
lovetime_etime=OSAUtil.get_now() +
datetime.timedelta(days=1))
self.__scoutevent_playdata = playdata
# イベント発生中設定.
config = BackendApi.get_current_scouteventconfig(model_mgr)
self.__preconfig_mid = config.mid
self.__preconfig_starttime = config.starttime
self.__preconfig_endtime = config.endtime
now = OSAUtil.get_now()
BackendApi.update_scouteventconfig(self.__eventmaster.id, now,
now + datetime.timedelta(days=1))
# レイドマスター.
raidmaster = self.create_dummy(DummyType.RAID_MASTER,
hp=1,
prizes=[prize.id],
helpprizes=[prize.id],
cabaretking=100,
demiworld=10)
self.__raidmaster = raidmaster
# ハプニング.
happeningmaster = self.create_dummy(DummyType.HAPPENING_MASTER,
raidmaster.id)
self.__happeningmaster = happeningmaster
# 短冊とキャストの情報.
tanzaku_master = self.create_dummy(
DummyType.SCOUT_EVENT_TANZAKU_CAST_MASTER,
self.__eventmaster.id,
0,
prizes=[prize.id])
self.__tanzaku_master = tanzaku_master
# イベント用レイド設定.
scouteventraidmaster = self.create_dummy(
DummyType.SCOUT_EVENT_RAID_MASTER,
self.__eventmaster.id,
self.__raidmaster.id,
tanzaku_number=tanzaku_master.number,
tanzaku_randmin=10,
tanzaku_randmax=10,
tanzaku_help_number=tanzaku_master.number,
tanzaku_help_randmin=3,
tanzaku_help_randmax=3)
self.__scouteventraidmaster = scouteventraidmaster
# 短冊所持情報.
tanzaku_nums = {tanzaku_master.number: 0}
tanzaku_data = self.create_dummy(
DummyType.SCOUT_EVENT_TANZAKU_CAST_DATA,
self.__player1.id,
self.__eventmaster.id,
tanzaku_nums=tanzaku_nums)
self.__tanzaku_data1 = tanzaku_data
tanzaku_data = self.create_dummy(
DummyType.SCOUT_EVENT_TANZAKU_CAST_DATA,
self.__player0.id,
self.__eventmaster.id,
tanzaku_nums=tanzaku_nums)
self.__tanzaku_data0 = tanzaku_data
# ハプニング情報.
eventvalue = HappeningUtil.make_scouteventvalue(self.__eventmaster.id)
happening = self.create_dummy(DummyType.HAPPENING,
self.__player0.id,
self.__happeningmaster.id,
progress=happeningmaster.execution,
eventid=eventvalue)
self.__happening = happening
# レイド.
raidboss = self.create_dummy(DummyType.RAID, self.__player0,
happeningmaster, happening)
raidboss.addDamageRecord(self.__player0.id, 1)
raidboss.refrectDamageRecord()
raidboss.raid.save()
self.__raid = raidboss
# 救援.
def addRequest(v_player, o_player):
model_mgr = ModelRequestMgr()
BackendApi.tr_add_friendrequest(model_mgr, v_player, o_player)
model_mgr.write_all()
model_mgr.write_end()
def addFriend(v_player, o_player):
model_mgr = ModelRequestMgr()
BackendApi.tr_add_friend(model_mgr, v_player.id, o_player.id)
model_mgr.write_all()
model_mgr.write_end()
addRequest(self.__player0, self.__player1)
addFriend(self.__player1, self.__player0)
model_mgr = ModelRequestMgr()
BackendApi.tr_send_raidhelp(model_mgr, self.__player0.id)
model_mgr.write_all()
model_mgr.write_end()
raidboss.addDamageRecord(self.__player1.id, 1)
raidboss.refrectDamageRecord()
raidboss.raid.save()
self.__player0.gold = 0
self.__player0.getModel(PlayerGold).save()
self.__player0.cardlimititem = 100
self.__player0.getModel(PlayerDeck).save()
self.__playerhappening = BackendApi.get_playerhappening(
model_mgr, self.__player0.id)
self.__present_num0 = BackendApi.get_present_num(self.__player0.id)
self.__present_num1 = BackendApi.get_present_num(self.__player1.id)
def setUp(self):
# DMMID.
self.__player = self.create_dummy(DummyType.PLAYER)
self.__player.lbtime = OSAUtil.get_now()
self.__player.getModel(PlayerLogin).save()
# デッキ.
deck = Deck(id=self.__player.id)
cardmaster = self.create_dummy(DummyType.CARD_MASTER)
deck.leader = self.create_dummy(DummyType.CARD, self.__player, cardmaster).id
for i in xrange(9):
cardmaster = self.create_dummy(DummyType.CARD_MASTER)
setattr(deck, 'mamber%d' % i, self.create_dummy(DummyType.CARD, self.__player, cardmaster).id)
deck.save()
# お知らせ.
for _ in range(5):
self.create_dummy(DummyType.TOP_BANNER_MASTER)
# イベント発生設定.
config = BackendApi.get_current_scouteventconfig(ModelRequestMgr())
self.__preconfig_mid = config.mid
BackendApi.update_scouteventconfig(0, config.starttime, config.endtime)
# カード.
table = []
cardmaster = self.create_dummy(DummyType.CARD_MASTER)
data = GachaBoxCardData(cardmaster.id, 10000)
table.append(data.to_data())
# グループ.
group = self.create_dummy(DummyType.GACHA_GROUP_MASTER, table=table)
# おまけ.
item = self.create_dummy(DummyType.ITEM_MASTER)
prize = self.create_dummy(DummyType.PRIZE_MASTER, item=item, itemnum=1)
bonus = [prize.id]
# ガチャ.
continuity = 10
boxdata = GachaBoxGroupData(group.id, 10000, continuity+1)
box = [boxdata.to_data()]
self.__gachamaster = self.create_dummy(DummyType.GACHA_MASTER, box=box, bonus=bonus, continuity=continuity, consumetype=Defines.GachaConsumeType.RANKING, consumevalue=10)
# ランキングガチャマスター.
wholeprizes = {
'normal' : [(1, bonus),]
}
self.__rankingmaster = self.create_dummy(DummyType.RANKING_GACHA_MASTER, self.__gachamaster.boxid, wholeprizes=wholeprizes)
# 達成報酬キュー.
queue0 = self.create_dummy(DummyType.RANKING_GACHA_WHOLE_PRIZE_QUEUE, self.__rankingmaster.id, point=100, prizes=bonus)
queue1 = self.create_dummy(DummyType.RANKING_GACHA_WHOLE_PRIZE_QUEUE, self.__rankingmaster.id, point=1000, prizes=bonus)
self.__queue = queue1
# 初めてプレイした時間.
self.create_dummy(DummyType.RANKING_GACHA_SCORE, self.__player.id, self.__rankingmaster.id, firstpoint=queue1.point)
# 受け取ったキューのID.
self.create_dummy(DummyType.RANKING_GACHA_WHOLE_PRIZE_DATA, self.__player.id, queue0.id - 1)
# 全プレ.
presenteveryone_list = BackendApi.get_presenteveryone_list_formypage(ModelRequestMgr())
prizeidlist = []
for presenteveryone in presenteveryone_list:
prizeidlist.extend(presenteveryone.prizes)
prizelist = BackendApi.get_prizelist(ModelRequestMgr(), prizeidlist)
self.__presenteveryone_presentlist = BackendApi.create_present_by_prize(ModelRequestMgr(), 0, prizelist, 0, do_set_save=False)
# ミッション報酬を受け取ってしまう.
model_mgr = ModelRequestMgr()
missionplaydata = BackendApi.get_current_panelmission_data(model_mgr, self.__player.id)
if missionplaydata:
panel = missionplaydata.mid
# マイページで確認するミッション.
mission_executer = PanelMissionConditionExecuter()
# 更新確認.
is_update = BackendApi.check_lead_update_panelmission(model_mgr, self.__player, panel, OSAUtil.get_now(), mission_executer)
if is_update:
def write():
model_mgr = ModelRequestMgr()
if mission_executer.isNeedCheck():
BackendApi.tr_complete_panelmission(model_mgr, self.__player.id, mission_executer, OSAUtil.get_now())
BackendApi.tr_receive_panelmission(model_mgr, self.__player.id, panel, self.__player.req_confirmkey, OSAUtil.get_now())
model_mgr.write_all()
model_mgr.write_end()
write()
self.__present_num = BackendApi.get_present_num(self.__player.id)
def __test_silhouette(self, scouteventmaster, stagemaster, player, cnt):
model_mgr = self.getModelMgr()
silhouette_rate = []
silhouette_dict = {}
silhouette_dict['gold'] = {}
silhouette_dict['silver'] = {}
silhouette_dict['bronze'] = {}
playdata = BackendApi.get_event_playdata(model_mgr,
scouteventmaster.id,
player.id,
using=backup_db)
dropitems = stagemaster.dropitems
itemselector = ScoutDropItemSelector(player, stagemaster, 0)
# the rate for each silhouette type
gold_rate = 0
silver_rate = 0
bronze_rate = 0
total_rate = 0
# create dictionary that would be sent to the template
for item in dropitems:
rate = int(item['rate'])
silhouette_type = item['silhouette']
total_rate += rate
cardid = int(item['master'])
tmp_dict = {}
tmp_dict[cardid] = {}
tmp_dict[cardid]['name'] = model_mgr.get_model(
CardMasterView, cardid, using=backup_db).name
tmp_dict[cardid]['occurrences'] = 0
tmp_dict[cardid]['rate'] = 0
tmp_dict[cardid]['bonus_rate_s'] = float(item["rate"]) / sum(
item['rate'] for item in dropitems) * 100
silhouette_dict[silhouette_type].update(tmp_dict)
if item['silhouette'] == 'gold':
gold_rate += rate
elif item['silhouette'] == 'silver':
silver_rate += rate
elif item['silhouette'] == 'bronze':
bronze_rate += rate
# execute scout `cnt` times and put save result
silhouette_list = self.__execute_eventscout(model_mgr, player,
stagemaster, playdata, cnt,
itemselector)
# number of gold, silver and bronze card chosen
number_of_gold = 0
number_of_silver = 0
number_of_bronze = 0
# 1. populate the dict that would be sent to the template
# 2. count the number of gold, silver or bronze card chosen
for item in silhouette_list:
cardid = int(item.data['card'])
silhouette_type = item.data['silhouette']
silhouette_dict[silhouette_type][cardid]['occurrences'] += 1
silhouette_dict[silhouette_type][cardid]['rate'] = float(
silhouette_dict[silhouette_type][cardid]
['occurrences']) / cnt * 100
# count the number of gold, silver or bronze card chosen
if item.data['silhouette'] == 'gold':
number_of_gold += 1
elif item.data['silhouette'] == 'silver':
number_of_silver += 1
elif item.data['silhouette'] == 'bronze':
number_of_bronze += 1
silhouette_rate.append({
'name':
'gold (金)',
'occurrences':
number_of_gold,
'rate':
float(number_of_gold) / cnt * 100,
'bonus_rate_s':
float(gold_rate) / total_rate * 100
})
silhouette_rate.append({
'name':
'silver (銀)',
'occurrences':
number_of_silver,
'rate':
float(number_of_silver) / cnt * 100,
'bonus_rate_s':
float(silver_rate) / total_rate * 100
})
silhouette_rate.append({
'name':
'bronze (ブロンズ)',
'occurrences':
number_of_bronze,
'rate':
float(number_of_bronze) / cnt * 100,
'bonus_rate_s':
float(bronze_rate) / total_rate * 100
})
# key rename
silhouette_dict['gold (金)'] = silhouette_dict.pop('gold')
silhouette_dict['silver (銀)'] = silhouette_dict.pop('silver')
silhouette_dict['bronze (ブロンズ)'] = silhouette_dict.pop('bronze')
def sortfun(sil_dict):
return sil_dict[1]['bonus_rate_s'], sil_dict[1]['occurrences']
self.html_param['silhouette_dict'] = silhouette_dict
self.html_param['silhouette_rate'] = silhouette_rate
def procPost(self):
"""パラメータを受け取ってスカウトイベント情報を用意する.
"""
model_mgr = self.getModelMgr()
error_msg_list = []
player = None
stagemaster = None
# スカウトイベントのマスターID.
mid = self.__get_int_value('_mid')
stgid = self.__get_int_value('_stgid')
scouteventmaster = BackendApi.get_scouteventmaster(model_mgr,
mid,
using=backup_db)
if scouteventmaster is None:
error_msg_list.append(u'存在しないスカウトイベントです.%s' % mid)
else:
# ステージのマスターID
if stgid < 1:
error_msg_list.append(u'ステージIDは自然値で指定してください.')
else:
stagemaster = ScoutEventStageMaster.fetchValues(
filters={
'eventid': scouteventmaster.id,
'stage': stgid
})
if not stagemaster:
error_msg_list.append(u'存在しないステージマスターです.%s' % stgid)
# ユーザーID
uid = self.__get_int_value('_uid')
if uid < 1:
error_msg_list.append(u'ユーザーIDは自然値で指定してください.')
else:
# プレーヤー
player = BackendApi.get_player(
self,
uid, [Player, PlayerAp, PlayerExp, PlayerFriend],
using=backup_db)
if not player:
error_msg_list.append(u'保存しないユーザーです。%s' % uid)
# 試験回数.
cnt = self.__get_int_value('_cnt')
if cnt < 1:
error_msg_list.append(u'試験回数は自然数で指定してください.')
# self.putAlertToHtmlParam(u'試験回数は自然数で指定してください.', AlertCode.ERROR)
cnt = min(1000000, cnt)
# set hmtl form values
self.html_param['cur_scoutevent'] = scouteventmaster
self.html_param['stgid'] = stgid
self.html_param['uid'] = uid
self.html_param['cnt'] = cnt
if error_msg_list:
self.putAlertToHtmlParam(u'<br/>'.join(error_msg_list),
AlertCode.ERROR)
return
# 試験.
self.__test_silhouette(scouteventmaster, stagemaster[0], player, cnt)
def __tr_buy_timeout(self, uid, paymentId):
model_mgr = ModelRequestMgr()
BackendApi.tr_shoptimeout(model_mgr, uid, paymentId)
model_mgr.write_all()
return model_mgr
def __tr_write_gacha_cancel(self, uid, paymentId):
model_mgr = ModelRequestMgr()
BackendApi.tr_gacha_cancel(model_mgr, uid, paymentId)
model_mgr.write_all()
return model_mgr
