def procHappening(self, mid, stagemaster, playdata, event):
"""ハプニング発生.
"""
model_mgr = self.getModelMgr()
happeningid = BackendApi.get_current_happeningid(
model_mgr, playdata.uid, using=playdata.current_db, reflesh=True)
happeningset = BackendApi.get_happening(model_mgr,
happeningid,
using=playdata.current_db)
if happeningset is None or happeningset.happening.is_end():
if settings_sub.IS_LOCAL:
raise CabaretError(u'ハプニングが発生していません')
url = UrlMaker.raidevent_top()
self.appRedirect(self.makeAppLinkUrlRedirect(url))
return
happeningraidset = HappeningRaidSet(happeningset)
self.html_param['happening'] = Objects.happening(
self, happeningraidset)
# レイドボス.
raidmaster = BackendApi.get_raid_master(model_mgr,
happeningset.master.boss,
using=settings.DB_READONLY)
self.html_param['boss'] = Objects.raidmaster(self, raidmaster)
self.setFromPage(
Defines.FromPages.RAIDEVENTSCOUT,
(stagemaster.id, urllib.quote(playdata.confirmkey, '')))
url = UrlMaker.happening()
self.html_param['url_happening'] = self.makeAppLinkUrl(url)
self.writeHtml(self.eventmaster, 'scout/happening')
def cb():
# ハプニング情報.
obj_happening = Objects.happening(
self, HappeningRaidSet(happeningset, raidboss), prizeinfo,
persons.get(o_player.dmmid))
self.html_param['happening'] = obj_happening
return obj_happening
def putHappeningInfo(self, do_get_end=False):
"""ハプニング情報作成.
"""
happeningraidset = self.getHappeningRaidSet()
if not happeningraidset:
return
happeningset = happeningraidset.happening
if not do_get_end and happeningset.happening.is_end():
return
# 獲得した報酬.
prizelist = self.getPooledPrizeList(happeningset.happening.is_canceled())
prizeinfo = BackendApi.make_prizeinfo(self, prizelist, using=settings.DB_READONLY)
# ハプニング情報.
obj_happening = Objects.happening(self, happeningraidset, prizeinfo)
self.html_param['happening'] = obj_happening
return obj_happening
def process(self):
try:
raidid = int(self.request.get(Defines.URLQUERY_ID))
except:
raidid = None
model_mgr = self.getModelMgr()
v_player = self.getViewerPlayer()
# レイド情報.
happeningraidset = None
if raidid:
happeningraidset = BackendApi.get_happeningraidset(
model_mgr, raidid, using=settings.DB_READONLY)
if happeningraidset is None or happeningraidset.raidboss is None:
raise CabaretError(u'存在しないレイドです', CabaretError.Code.NOT_DATA)
# ハプニング情報.
obj_happening = Objects.happening(self, happeningraidset)
self.json_result_param['happening'] = obj_happening
# ダメージ履歴.
func_put_attacklog = self.putRaidAttackLog(happeningraidset.raidboss)
# お助け.
func_put_playerlist = self.putHelpFriend(happeningraidset.raidboss)
if func_put_attacklog or func_put_playerlist:
self.execute_api()
if func_put_attacklog:
func_put_attacklog()
if func_put_playerlist:
func_put_playerlist()
# 確認キー.
self.json_result_param['battlekey'] = v_player.req_confirmkey
self.writeAppJson()
def procHappening(self, scoutmaster, playdata, event):
"""ハプニング発生.
"""
using = playdata.current_db
model_mgr = self.getModelMgr()
happeningid = BackendApi.get_current_happeningid(model_mgr,
playdata.uid,
using=using,
reflesh=True)
happeningset = BackendApi.get_happening(model_mgr,
happeningid,
using=using)
if happeningset is None or happeningset.happening.is_end():
if settings_sub.IS_LOCAL:
raise CabaretError(u'ハプニングが発生していません')
url = UrlMaker.scout()
self.appRedirect(self.makeAppLinkUrlRedirect(url))
return
raidboss = BackendApi.get_raid(
model_mgr,
happeningset.id,
using=using,
happening_eventvalue=happeningset.happening.event)
happeningraidset = HappeningRaidSet(happeningset, raidboss)
self.html_param['happening'] = Objects.happening(
self, happeningraidset)
# レイドボス.
raidmaster = BackendApi.get_raid_master(model_mgr,
happeningset.master.boss,
using=settings.DB_READONLY)
self.html_param['boss'] = Objects.raidmaster(self, raidmaster)
self.writeAppHtml('scout/happening')
def process(self):
model_mgr = self.getModelMgr()
v_player = self.getViewerPlayer()
uid = v_player.id
# 開催中判定.
cur_eventmaster = self.getCurrentRaidEvent()
mid = cur_eventmaster.id
# 現在発生中のレイド.
happeningraidset = self.getHappeningRaidSet()
if happeningraidset is None or happeningraidset.raidboss is None:
self.appRedirect(self.makeAppLinkUrlRedirect(UrlMaker.mypage()))
return
# イベントのレイド判定.
happeningset = happeningraidset.happening
raidboss = happeningraidset.raidboss
eventid = HappeningUtil.get_raideventid(happeningset.happening.event)
if happeningset.happening.oid != uid:
# 自分のじゃないのは救援詳細へ.
self.appRedirect(self.makeAppLinkUrlRedirect(UrlMaker.raidhelpdetail(happeningset.id)))
return
elif eventid != mid:
# イベントじゃないレイド.
self.appRedirect(self.makeAppLinkUrlRedirect(UrlMaker.happening()))
return
elif not happeningset.happening.is_active():
# 終了済み.
self.appRedirect(self.makeAppLinkUrlRedirect(UrlMaker.raidend(happeningset.happening.id)))
return
raideventraidmaster = BackendApi.get_raidevent_raidmaster(model_mgr, cur_eventmaster.id, raidboss.master.id, using=settings.DB_READONLY)
# キャストを借りる.
func_put_playerlist = self.putHelpFriend(raidboss)
# ダメージ履歴.
func_put_attacklog = self.putRaidAttackLog(raidboss)
# イベント情報.
config = BackendApi.get_current_raideventconfig(model_mgr, using=settings.DB_READONLY)
self.html_param['raidevent'] = Objects.raidevent(self, cur_eventmaster, config)
# レイド情報.
obj_happening = Objects.happening(self, happeningraidset)
self.html_param['happening'] = obj_happening
# 実行リンク 等倍と3倍.
url = UrlMaker.raiddo(raidboss.id, v_player.req_confirmkey)
self.html_param['url_exec'] = self.makeAppLinkUrl(url)
self.html_param['url_exec_strong'] = self.makeAppLinkUrl(OSAUtil.addQuery(url, Defines.URLQUERY_STRONG, 1))
# 諦める.
self.html_param['url_happeningcancel_yesno'] = self.makeAppLinkUrl(UrlMaker.happeningcancel_yesno())
# 初心者フラグ.
is_beginer = BackendApi.check_raidevent_beginer(model_mgr, uid, cur_eventmaster, config, using=settings.DB_READONLY)
self.html_param['is_beginer'] = is_beginer
# イベントデータ.
scorerecord = BackendApi.get_raidevent_scorerecord(model_mgr, mid, uid, using=settings.DB_READONLY)
rank = BackendApi.get_raidevent_rank(cur_eventmaster.id, uid)
rank_beginer = BackendApi.get_raidevent_rank(cur_eventmaster.id, uid, is_beginer=True)
self.html_param['raideventscore'] = Objects.raidevent_score(cur_eventmaster, scorerecord, rank, rank_beginer)
# 特攻カード.
BackendApi.put_raidevent_specialcard_info(self, uid, raideventraidmaster, using=settings.DB_READONLY)
# このページに戻ってくるリンク.
self.setFromPage(Defines.FromPages.HAPPENING, happeningset.id)
BackendApi.put_bprecover_uselead_info(self)
self.html_param['url_deck_raid'] = self.makeAppLinkUrl(UrlMaker.deck_raid())
# デッキ情報.
deckcardlist = self.getDeckCardList()
self.putDeckParams(deckcardlist)
self.execute_api()
if func_put_attacklog:
func_put_attacklog()
if func_put_playerlist:
func_put_playerlist()
# 説明とランキングのリンク.
url = UrlMaker.raidevent_top(mid)
self.html_param['url_raidevent_top'] = self.makeAppLinkUrl(url)
self.html_param['player'] = Objects.player(self, v_player)
self.writeHtml(cur_eventmaster, 'bossappear')
def process(self):
args = self.getUrlArgs('/happeningend/')
model_mgr = self.getModelMgr()
happeningid = str(args.get(0, ''))
happeningraid = None
if happeningid.isdigit():
happeningraid = BackendApi.get_happeningraidset(
model_mgr, int(happeningid), using=settings.DB_READONLY)
if happeningraid is None:
raise CabaretError(u'ハプニングが見つかりません',
CabaretError.Code.ILLEGAL_ARGS)
# プレイヤー情報.
v_player = self.getViewerPlayer()
happeningset = happeningraid.happening
raideventid = HappeningUtil.get_raideventid(
happeningset.happening.event)
if happeningset.happening.is_end(
) and not happeningset.happening.is_missed_and_not_end():
pass
else:
if happeningset.happening.is_cleared():
if v_player.id == happeningset.happening.oid:
# 終了書き込みをさせる.
if settings_sub.IS_LOCAL:
raise CabaretError(u'まだ終わっていません')
url = UrlMaker.raidend(happeningset.happening.id)
self.appRedirect(self.makeAppLinkUrlRedirect(url))
return
else:
pass
elif happeningset.happening.is_missed_and_not_end():
if v_player.id == happeningset.happening.oid:
# 終了書き込みをさせる.
if settings_sub.IS_LOCAL and not self.request.get('_test'):
raise CabaretError(u'終了処理を行っていません')
elif raideventid:
self.appRedirect(
self.makeAppLinkUrlRedirect(UrlMaker.happening()))
return
else:
self.writeHappeningMissed(happeningset.id)
else:
pass
else:
if settings_sub.IS_LOCAL:
raise CabaretError(u'まだ終わっていません')
url = UrlMaker.happening()
self.appRedirect(self.makeAppLinkUrlRedirect(url))
return
eventmaster = None
if raideventid:
eventmaster = BackendApi.get_raideventmaster(
model_mgr, raideventid, using=settings.DB_READONLY)
if eventmaster:
# イベント開催中.
self.html_param['url_raidevent_top'] = self.makeAppLinkUrl(
UrlMaker.raidevent_top(eventmaster.id))
self.html_param['prize'] = None
if eventmaster.flag_dedicated_stage:
self.html_param[
'url_raidevent_scouttop'] = self.makeAppLinkUrl(
UrlMaker.raidevent_scouttop())
if happeningset.happening.is_canceled():
# キャンセル.
self.html_param['cancel'] = True
self.writeAppHtml('raidevent/failed')
elif happeningset.happening.is_missed():
# 失敗.
self.html_param['cancel'] = False
self.writeAppHtml('raidevent/failed')
else:
# 成功.
url = UrlMaker.raidend(happeningset.happening.id)
self.appRedirect(self.makeAppLinkUrlRedirect(url))
return
else:
model_mgr = self.getModelMgr()
# スカウトイベント.
scouteventmaster = BackendApi.get_current_scouteventmaster(
model_mgr, using=settings.DB_READONLY)
if scouteventmaster:
scouteventconfig = BackendApi.get_current_scouteventconfig(
model_mgr, using=settings.DB_READONLY)
self.html_param['scoutevent'] = Objects.scouteventmaster(
self, scouteventmaster, scouteventconfig)
self.html_param[
'url_scoutevent_scouttop'] = self.makeAppLinkUrl(
UrlMaker.scoutevent())
# ハプニングの報酬.
prizeinfo = None
if v_player.id == happeningset.happening.oid:
prizelist = self.getPooledPrizeList(
happeningset.happening.is_canceled())
if prizelist:
prizeinfo = BackendApi.make_prizeinfo(
self, prizelist, using=settings.DB_READONLY)
# 成否.
if happeningset.happening.state in (Defines.HappeningState.END,
Defines.HappeningState.CLEAR):
# ハプニング情報.
self.html_param['happening'] = Objects.happening(
self, happeningraid, prizeinfo)
# レイドの報酬.
self.html_param['raidprize'] = Objects.raidprize(
self, v_player, happeningraid.raidboss,
happeningset.happening.items.get('dropitems', []))
self.writeAppHtml('happening/prizeget')
else:
self.html_param['prize'] = prizeinfo
self.html_param['cancel'] = happeningset.happening.is_canceled(
)
self.writeAppHtml('happening/failed')
def procDetail(self, helplog):
"""詳細.
"""
model_mgr = self.getModelMgr()
v_player = self.getViewerPlayer()
# レイド情報.
raidboss = BackendApi.get_raid(model_mgr,
helplog.raidid,
using=settings.DB_READONLY,
get_instance=True)
is_owner = v_player.id == raidboss.raid.oid
if not (is_owner
or v_player.id in raidboss.getDamageRecordUserIdList()):
# 閲覧できない.
self.appRedirect(self.makeAppLinkUrlRedirect(UrlMaker.happening()))
return
damagerecord = raidboss.getDamageRecord(v_player.id)
is_cleared = raidboss.raid.hp == 0
is_canceled = False
prizelist = None
# ハプニング情報.
happeningset = BackendApi.get_happening(model_mgr,
raidboss.id,
using=settings.DB_READONLY)
if happeningset is None:
BackendApi.save_raidlog_idlist(model_mgr,
v_player.id,
using=settings.DB_READONLY)
url = UrlMaker.raidloglist()
self.appRedirect(self.makeAppLinkUrlRedirect(url))
return
# イベント情報を設定.
BackendApi.reset_raidboss_eventraidmaster(model_mgr,
raidboss,
happeningset.happening.event,
using=settings.DB_READONLY)
raideventmaster = None
excludes = None
raideventid = HappeningUtil.get_raideventid(
happeningset.happening.event)
if raideventid:
raideventmaster = BackendApi.get_raideventmaster(
model_mgr, raideventid, using=settings.DB_READONLY)
destroypoint_info = None
if is_cleared:
bonusscore = 0
if happeningset.happening.oid == v_player.id:
specialscore_obj = BackendApi.get_model(
model_mgr,
RaidEventSpecialBonusScoreLog,
raidboss.id,
using=settings.DB_READONLY)
if isinstance(specialscore_obj,
RaidEventSpecialBonusScoreLog):
bonusscore = specialscore_obj.bonusscore
else:
_helpbonusscore = BackendApi.get_raidevent_helpspecialbonusscore(
raidboss.id, v_player.id, using=settings.DB_DEFAULT)
if isinstance(_helpbonusscore,
RaidEventHelpSpecialBonusScore):
bonusscore = _helpbonusscore.bonusscore
destroypoint_info = BackendApi.make_raidevent_destroypoint_info(
model_mgr,
v_player.id,
raideventmaster,
HappeningRaidSet(happeningset, raidboss),
bonusscore,
using=settings.DB_READONLY)
# MVP.
mvp_uidlist = raidboss.getMVPList()
self.html_param['mvp_uidlist'] = mvp_uidlist
self.html_param['destroy_time'] = helplog.ctime
# イベント情報.
config = BackendApi.get_current_raideventconfig(
model_mgr, using=settings.DB_READONLY)
self.html_param['raidevent'] = Objects.raidevent(
self, raideventmaster, config)
# シャンパン.
if 0 < damagerecord.champagne_num_add:
self.html_param[
'champagne_num_pre'] = damagerecord.champagne_num_pre
self.html_param[
'champagne_num_post'] = damagerecord.champagne_num_post
self.html_param[
'champagne_num_add'] = damagerecord.champagne_num_add
# 素材.
if 0 < damagerecord.material_num:
materials = raideventmaster.getMaterialDict()
material_id = materials.get(
raidboss.raideventraidmaster.material)
if material_id:
materialmaster = BackendApi.get_raidevent_materialmaster(
model_mgr, material_id, using=settings.DB_READONLY)
materialnumdata = BackendApi.get_raidevent_materialdata(
model_mgr, v_player.id, using=settings.DB_READONLY)
obj = Objects.raidevent_material(
self, materialmaster,
materialnumdata.getMaterialNum(
raideventid,
raidboss.raideventraidmaster.material))
obj['num_add'] = damagerecord.material_num
self.html_param['material'] = obj
self.html_param['destroypoint_info'] = destroypoint_info
elif raidboss.scouteventraidmaster:
scouteventid = raidboss.scouteventraidmaster.eventid
tanzaku_number = raidboss.get_tanzaku_number(v_player.id)
tanzakumaster = BackendApi.get_scoutevent_tanzakumaster(
model_mgr,
scouteventid,
tanzaku_number,
using=settings.DB_READONLY
) if tanzaku_number is not None else None
if tanzakumaster is not None:
# 短冊.
self.html_param[
'scoutevent_tanzaku'] = Objects.scoutevent_tanzaku(
self, tanzakumaster)
self.html_param[
'tanzaku_num_pre'] = damagerecord.tanzaku_num_pre
self.html_param[
'tanzaku_num_post'] = damagerecord.tanzaku_num_post
self.html_param['tanzaku_num_add'] = damagerecord.tanzaku_num
if raideventmaster or RaidBoss.RAIDEVENT_PRIZE_UPDATETIME <= happeningset.happening.ctime:
if is_cleared:
# 報酬.
prizelist = []
if is_owner:
# 発見者.
if raideventmaster:
cabaretking = raidboss.get_cabaretking()
if 0 < cabaretking:
prizelist.append(
PrizeData.create(cabaretking=cabaretking))
prizelist.extend(
BackendApi.get_prizelist(model_mgr,
raidboss.master.prizes,
using=settings.DB_READONLY))
prizelist.extend(
BackendApi.aggregate_happeningprize(
happeningset.happening))
elif 0 < damagerecord.damage_cnt:
# 救援者.
if raideventmaster:
demiworld = raidboss.get_demiworld()
if 0 < demiworld:
prizelist.append(
PrizeData.create(demiworld=demiworld))
prizelist = BackendApi.get_prizelist(
model_mgr,
raidboss.master.helpprizes,
using=settings.DB_READONLY)
elif happeningset.happening.is_canceled(
) and v_player.id == happeningset.happening.oid:
# キャンセル.
prizelist = BackendApi.aggregate_happeningprize(
happeningset.happening, cancel=True)
is_canceled = True
# ダメージ履歴.
func_put_attacklog = self.putRaidAttackLog(raidboss, excludes=excludes)
prizeinfo = None
if prizelist:
prizeinfo = BackendApi.make_prizeinfo(self,
prizelist,
using=settings.DB_READONLY)
persons = {}
dmmid = ''
if not is_owner:
o_players = BackendApi.get_players(self,
[happeningset.happening.oid],
[],
using=settings.DB_READONLY)
if o_players:
o_player = o_players[0]
dmmid = o_player.dmmid
persons = BackendApi.get_dmmplayers(self,
o_players,
using=settings.DB_READONLY,
do_execute=False)
self.html_param['player'] = Objects.player(self, v_player)
self.html_param['is_cleared'] = is_cleared
self.html_param['is_canceled'] = is_canceled
self.execute_api()
self.html_param['happening'] = Objects.happening(
self,
HappeningRaidSet(happeningset, raidboss),
prizeinfo,
o_person=persons.get(dmmid))
if func_put_attacklog:
func_put_attacklog()
self.setFromPage(Defines.FromPages.RAIDLOG, helplog.id)
self.html_param['url_trade'] = self.makeAppLinkUrl(UrlMaker.trade(),
add_frompage=True)
self.writeHtmlSwitchEvent('log',
eventmaster=raideventmaster,
basedir_normal='raid')
def __procView(self, uid):
"""詳細表示.
"""
model_mgr = self.getModelMgr()
now = OSAUtil.get_now()
playerlist = BackendApi.get_players(self, [uid], using=backup_db)
if not playerlist:
self.putAlertToHtmlParam(u'見つかりませんでした', AlertCode.ERROR)
self.__procSearch()
return
player = playerlist[0]
person = BackendApi.get_dmmplayers(self, [player], using=backup_db, do_execute=True).get(player.dmmid)
obj_player = Objects.player(self, player, person)
obj_player['userType'] = person.userType or u'一般'
self.html_param['player'] = obj_player
# 招待してくれた人.
invitedata = BackendApi.get_model(model_mgr, InviteData, player.dmmid, using=backup_db)
if invitedata and invitedata.fid:
playerlist = BackendApi.get_players(self, [invitedata.fid], [], using=backup_db, model_mgr=model_mgr)
invite_from_player = playerlist[0] if playerlist else None
if invite_from_player:
invite_from_person = BackendApi.get_dmmplayers(self, [invite_from_player], using=backup_db, do_execute=True).get(invite_from_player.dmmid)
self.html_param['invitedata'] = {
'url' : self.makeAppLinkUrlAdmin(UrlMaker.view_player(invite_from_player.id)),
'player' : Objects.player(self, invite_from_player, invite_from_person),
'ctime' : invitedata.ctime,
'state' : Defines.InviteState.NAMES[invitedata.state],
}
# 招待した人数.
inviterecordlist = Invite.fetchValues(filters={'uid':player.id}, order_by='mid', using=backup_db)
if inviterecordlist:
midlist = [inviterecord.mid for inviterecord in inviterecordlist]
invitemasterdict = BackendApi.get_model_dict(model_mgr, InviteMaster, midlist, get_instance=True, using=backup_db)
obj_inviterecordlist = []
for inviterecord in inviterecordlist:
invitemaster = invitemasterdict.get(inviterecord.mid)
obj_inviterecordlist.append({
'id' : invitemaster.id,
'name' : invitemaster.name,
'cnt' : inviterecord.cnt,
})
self.html_param['inviterecordlist'] = obj_inviterecordlist
regist = False
if player.getModel(PlayerRegist) is not None:
regist = True
# アイテム.
itemidlist = Defines.ItemEffect.NAMES.keys()
itemmasterdict = BackendApi.get_model_dict(model_mgr, ItemMaster, itemidlist, using=backup_db)
itemnums = BackendApi.get_model_list(model_mgr, Item, [Item.makeID(uid, iid) for iid in Defines.ItemEffect.NAMES.keys()], using=backup_db)
iteminfolist = []
for item in itemnums:
master = itemmasterdict.get(item.mid)
if master:
iteminfolist.append({
'master' : master,
'nums' : item,
})
self.html_param['itemlist'] = iteminfolist
# 所持カード.
deck = BackendApi.get_deck(uid, arg_model_mgr=model_mgr, using=backup_db)
raiddeck = BackendApi.get_raid_deck(uid, arg_model_mgr=model_mgr, using=backup_db)
cardlist = BackendApi.get_card_list(uid, arg_model_mgr=model_mgr, using=backup_db)
obj_cardlist = []
obj_deckcards = {}
obj_raiddeckcards = {}
cardcounts = {}
for cardset in cardlist:
obj_card = Objects.card(self, cardset, deck)
obj_card['way'] = Defines.CardGetWayType.NAMES.get(cardset.card.way, u'不明')
obj_card['raiddeckmember'] = raiddeck.is_member(cardset.id)
if obj_card['deckmember']:
obj_deckcards[cardset.id] = obj_card
elif obj_card['raiddeckmember']:
obj_card['raiddeckmember'] = True
obj_raiddeckcards[cardset.id] = obj_card
else:
obj_cardlist.append(obj_card)
mid = cardset.master.id
data = cardcounts[mid] = cardcounts.get(mid) or {'name':cardset.master.name, 'cnt':0}
data['cnt'] += 1
self.html_param['deckcardlist'] = [obj_deckcards[cardid] for cardid in deck.to_array()]
self.html_param['raiddeckcardlist'] = [obj_raiddeckcards[cardid] for cardid in raiddeck.to_array() if obj_raiddeckcards.get(cardid)]
self.html_param['cardlist'] = obj_cardlist
self.html_param['cardcounts'] = cardcounts
# フレンド.
table = {
'friendlist' : BackendApi.get_friend_idlist,
'friendrequestlist' : BackendApi.get_friendrequest_send_idlist,
'friendreceivelist' : BackendApi.get_friendrequest_receive_idlist,
}
for k,func in table.items():
uidlist = func(uid, arg_model_mgr=model_mgr, using=backup_db)
friendlist = BackendApi.get_players(self, uidlist, [], using=backup_db)
friendmodels = BackendApi.get_model_dict(model_mgr, Friend, [Friend.makeID(uid, fid) for fid in uidlist], using=backup_db)
obj_friendlist = []
for friend in friendlist:
obj_friend = self.makeListPlayer(friend)
friendmodel = friendmodels.get(Friend.makeID(uid, friend.id))
if friendmodel:
obj_friend['f_time'] = friendmodel.ctime.strftime("%Y/%m/%d %H:%M:%S")
obj_friendlist.append(obj_friend)
self.html_param[k] = obj_friendlist
# バトル情報.
self.html_param['battleKOs'] = BackendApi.get_battleKOs(uid, arg_model_mgr=model_mgr, using=backup_db)
battleplayer = BackendApi.get_battleplayer(model_mgr, uid, using=backup_db)
if battleplayer:
# 最大ランク.
self.html_param['max_rank'] = BackendApi.get_battlerank_max(model_mgr, using=backup_db)
rankmaster = BackendApi.get_battlerank(model_mgr, battleplayer.rank, using=backup_db)
self.html_param['battleplayer'] = Objects.battleplayer(self, battleplayer, rankmaster)
# ハプニング.
if player.getModel(PlayerHappening):
happeningraidset = BackendApi.get_happeningraidset(model_mgr, player.happening, using=backup_db)
if happeningraidset:
model_happening = happeningraidset.happening.happening
prize = BackendApi.aggregate_happeningprize(model_happening, model_happening.is_canceled())
self.html_param['happening'] = Objects.happening(self, happeningraidset, prize)
self.html_param['is_ban'] = not BackendApi.check_player_ban(model_mgr, uid, using=backup_db)
# スカウトイベント.
scevent = []
config = BackendApi.get_current_scouteventconfig(model_mgr, using=backup_db)
if config:
eventmaster = BackendApi.get_scouteventmaster(model_mgr, config.mid, using=backup_db)
if eventmaster:
playdata = BackendApi.get_event_playdata(model_mgr, eventmaster.id, uid, using=backup_db)
arr = BackendApi.get_event_stages(model_mgr, [playdata.stage], using=backup_db)
stage = arr[0] if arr else None
arr = BackendApi.get_event_stages(model_mgr, [playdata.cleared], using=backup_db)
cleared = arr[0] if arr else None
scorerecord = BackendApi.get_scoutevent_scorerecord(model_mgr, eventmaster.id, uid, using=backup_db)
produce_list = BackendApi.get_scoutevent_presentprizemaster_by_eventid(model_mgr, eventmaster.id, using=backup_db)
produce_data = BackendApi.get_scoutevent_presentnums_record(model_mgr, eventmaster.id, uid, using=backup_db)
if produce_data:
nums = produce_data.nums
else:
nums = {}
obj_produce_list = [(produce.name, nums.get(produce.number, 0)) for produce in produce_list]
tanzaku_list = BackendApi.get_scoutevent_tanzakumaster_by_eventid(model_mgr, eventmaster.id, using=backup_db)
obj_tanzaku_list = None
current_cast_number = -1
if tanzaku_list:
tanzakudata = ScoutEventTanzakuCastData.getByKey(ScoutEventTanzakuCastData.makeID(uid, eventmaster.id), using=backup_db)
current_cast_number = tanzakudata.current_cast if tanzakudata else -1
obj_tanzaku_list = [dict(Objects.scoutevent_tanzaku(self, tanzakumaster, tanzakudata), current=current_cast_number==tanzakumaster.number) for tanzakumaster in tanzaku_list]
event = {'name': eventmaster.name,
'stage': stage,
'cleared': cleared,
'scorerecord': scorerecord,
'produce_list' : obj_produce_list,
'tanzaku_list' : obj_tanzaku_list,
}
scevent.insert(0, event)
self.html_param['scevent'] = scevent
# バトルイベント.
battleevent_config = BackendApi.get_current_battleeventconfig(model_mgr, using=backup_db)
if battleevent_config.mid:
eventmaster = BackendApi.get_battleevent_master(model_mgr, battleevent_config.mid, using=backup_db)
if eventmaster:
eventid = eventmaster.id
obj_battleevent = {
'id' : eventmaster.id,
'name' : eventmaster.name,
'point' : 0,
'point_total' : 0,
'rank' : 0,
'rankname' : u'未参加',
'fame' : 0,
'fame_next' : 0,
}
scorerecord = BackendApi.get_battleevent_scorerecord(model_mgr, eventid, uid, using=backup_db)
if scorerecord:
obj_battleevent.update({
'point' : scorerecord.getPointToday(),
'point_total' : scorerecord.point_total,
})
rankrecord = BackendApi.get_battleevent_rankrecord(model_mgr, eventid, uid, using=backup_db)
if rankrecord:
rank = rankrecord.getRank(battleevent_config)
rankmaster = BackendApi.get_battleevent_rankmaster(model_mgr, eventid, rank, using=backup_db)
obj_battleevent.update({
'rank' : rank,
'rankname' : rankmaster.name if rankmaster else u'不明',
'fame' : rankrecord.fame,
'fame_next' : rankrecord.fame_next,
})
# ランク別バトルポイント.
rankmasterlist = BackendApi.get_battleevent_rankmaster_by_eventid(model_mgr, eventid, using=backup_db, do_check_open=False)
idlist = [BattleEventScorePerRank.makeID(uid, BattleEventScorePerRank.makeMid(eventid, rankmaster.rank)) for rankmaster in rankmasterlist]
scoredata_dict = BackendApi.get_model_dict(model_mgr, BattleEventScorePerRank, idlist, using=backup_db, key=lambda x:x.rank)
obj_rankscorelist = []
rankmasterlist.sort(key=lambda x:x.rank, reverse=True)
for rankmaster in rankmasterlist:
obj_rankscorelist.append({
'rank' : rankmaster.rank,
'rankname' : rankmaster.name if rankmaster else u'不明',
'score' : scoredata_dict[rankmaster.rank].point if scoredata_dict.get(rankmaster.rank) else 0,
})
obj_battleevent['rankscorelist'] = obj_rankscorelist
# 現在の贈り物.
presentdata = BackendApi.get_model(model_mgr, BattleEventPresentData, BattleEventPresentData.makeID(uid, eventid), using=backup_db)
obj_presentdata = None
if presentdata and presentdata.getData():
data = presentdata.getData()
presentmaster = BackendApi.get_battleeventpresent_master(model_mgr, eventid, data['number'], using=backup_db)
contentmaster = BackendApi.get_battleeventpresent_content_master(model_mgr, data['content'], using=backup_db)
obj_presentdata = {
'present' : presentmaster,
'content' : contentmaster,
'point' : presentdata.point,
}
obj_battleevent['presentdata'] = obj_presentdata
self.html_param['battleevent'] = obj_battleevent
obj_player['regist'] = regist
# ガチャチケット.
tickettypes = Defines.GachaConsumeType.GachaTicketType.NAMES.keys()
ticket_num_models = BackendApi.get_additional_gachaticket_nums(model_mgr, uid, tickettypes, using=backup_db)
ticket_list = []
for tickettype in tickettypes:
num_model = ticket_num_models.get(tickettype)
ticket_list.append({
'name' : Defines.GachaConsumeType.GachaTicketType.NAMES[tickettype],
'num' : num_model.num if num_model else 0,
})
self.html_param['ticket_list'] = ticket_list
# ランキングガチャ.
rankinggachascore_list = RankingGachaScore.fetchByOwner(uid, using=backup_db)
rankinggacha_master_dict = BackendApi.get_rankinggacha_master_dict(model_mgr, [rankinggachascore.mid for rankinggachascore in rankinggachascore_list], using=backup_db)
obj_rankinggacha_list = []
for rankinggachascore in rankinggachascore_list:
rankinggacha_master = rankinggacha_master_dict.get(rankinggachascore.mid)
obj_rankinggacha_list.append({
'id' : rankinggachascore.mid,
'name' : rankinggacha_master.name if rankinggacha_master else u'不明',
'single' : rankinggachascore.single,
'total' : rankinggachascore.total,
'firstpoint' : rankinggachascore.firstpoint,
'firsttime' : (rankinggachascore.firsttime or OSAUtil.get_datetime_min()).strftime("%Y-%m-%d %H:%M:%S"),
})
self.html_param['rankinggacha_list'] = obj_rankinggacha_list
# 店舗.
cabaclubstoremaster_all = BackendApi.get_cabaretclub_store_master_all(model_mgr, using=backup_db)
midlist = [cabaclubstoremaster.id for cabaclubstoremaster in cabaclubstoremaster_all]
store_set_dict = BackendApi.get_cabaretclub_storeset_dict(model_mgr, uid, midlist, using=backup_db)
obj_store_list = []
for cabaclubstoremaster in cabaclubstoremaster_all:
store_set = store_set_dict.get(cabaclubstoremaster.id) or CabaclubStoreSet(cabaclubstoremaster, None)
obj = Objects.cabaclubstore(self, store_set, now)
obj['utime'] = store_set.playerdata.utime
obj['rtime'] = store_set.playerdata.rtime
obj['etime'] = store_set.playerdata.etime
obj_store_list.append(obj)
self.html_param['cabaclubstore_list'] = obj_store_list
# 称号.
title_set = BackendApi.get_current_title_set(model_mgr, uid, now, using=backup_db)
if title_set:
self.html_param['title'] = Objects.title(self, title_set.master, title_set.playerdata, now)
self.writeAppHtml('infomations/view_player/detail')
def process(self):
args = self.getUrlArgs('/raidhelpdetail/')
raidid = str(args.get(0, ''))
if not raidid.isdigit():
if settings_sub.IS_LOCAL:
raise CabaretError(u'レイドIDの指定がおかしい')
self.__redirectWithError(self.makeAppLinkUrlRedirect(UrlMaker.happening()), u'Illegal ID.')
return
raidid = int(raidid)
model_mgr = self.getModelMgr()
v_player = self.getViewerPlayer()
uid = v_player.id
# レイド情報.
raidboss = BackendApi.get_raid(model_mgr, raidid, using=settings.DB_READONLY)
if raidboss is None:
if settings_sub.IS_LOCAL:
raise CabaretError(u'存在しないレイド')
raidlog = BackendApi.get_raidlog_by_raidid(model_mgr, uid, raidid, using=settings.DB_READONLY)
if raidlog:
self.__redirectWithError(self.makeAppLinkUrlRedirect(UrlMaker.raidlogdetail(raidlog.id)), u'Raid not Found.')
else:
self.__redirectWithError(self.makeAppLinkUrlRedirect(UrlMaker.happening()), u'Raid not Found and Log not Found.')
return
elif raidboss.raid.oid == uid:
if settings_sub.IS_LOCAL:
raise CabaretError(u'自分のレイド')
self.__redirectWithError(self.makeAppLinkUrlRedirect(UrlMaker.happening()), u'Mine.')
return
happeningset = BackendApi.get_happening(model_mgr, raidid, using=settings.DB_READONLY)
is_end = False
if happeningset.happening.is_active():
# 参加可能かを確認.
if not BackendApi.check_raid_joinable(model_mgr, raidboss, uid, using=settings.DB_READONLY):
# もう一度開催確認.
happeningset = BackendApi.get_happening(ModelRequestMgr(), raidid, using=settings.DB_DEFAULT)
if happeningset.happening.is_active():
if settings_sub.IS_LOCAL:
raise CabaretError(u'参加できないレイド')
self.__redirectWithError(self.makeAppLinkUrlRedirect(UrlMaker.happening()), u'Cannot Join.')
return
else:
# チェック中に終了した.
is_end = True
else:
is_end = True
BackendApi.reset_raidboss_eventraidmaster(model_mgr, raidboss, happeningset.happening.event, using=settings.DB_READONLY)
# プレイヤー情報.
self.html_param['player'] = Objects.player(self, v_player)
# ダメージ履歴.
func_put_attacklog = self.putRaidAttackLog(raidboss)
# お助け.
func_put_playerlist = self.putHelpFriend(raidboss)
# ハプニング情報.
o_players = BackendApi.get_players(self, [happeningset.happening.oid], [], using=settings.DB_READONLY)
dmmid = ''
if o_players:
o_player = o_players[0]
dmmid = o_player.dmmid
persons = BackendApi.get_dmmplayers(self, o_players, using=settings.DB_READONLY, do_execute=False)
else:
persons = {}
if not is_end:
# デッキ情報.
deckcardlist = self.getDeckCardList()
self.putDeckParams(deckcardlist)
self.execute_api()
obj_happening = Objects.happening(self, HappeningRaidSet(happeningset, raidboss), o_person=persons.get(dmmid))
self.html_param['happening'] = obj_happening
if func_put_attacklog or func_put_playerlist:
if func_put_attacklog:
func_put_attacklog()
if func_put_playerlist:
func_put_playerlist()
self.setFromPage(Defines.FromPages.RAID, raidid)
BackendApi.put_bprecover_uselead_info(self)
self.html_param['url_deck_raid'] = self.makeAppLinkUrl(UrlMaker.deck_raid())
# 実行Url.
url = UrlMaker.raiddo(raidboss.id, v_player.req_confirmkey)
self.html_param['url_exec_strong'] = self.makeAppLinkUrl(OSAUtil.addQuery(url, Defines.URLQUERY_STRONG, 1))
self.html_param['url_exec'] = self.makeAppLinkUrl(url)
self.html_param['url_trade'] = self.makeAppLinkUrl(UrlMaker.trade(), add_frompage=True)
cur_eventmaster = BackendApi.get_current_raideventmaster(model_mgr, using=settings.DB_READONLY)
eventid = HappeningUtil.get_raideventid(happeningset.happening.event)
if cur_eventmaster and cur_eventmaster.id == eventid:
# イベント情報.
config = BackendApi.get_current_raideventconfig(model_mgr, using=settings.DB_READONLY)
self.html_param['raidevent'] = Objects.raidevent(self, cur_eventmaster, config)
# イベントデータ.
scorerecord = BackendApi.get_raidevent_scorerecord(model_mgr, cur_eventmaster.id, uid, using=settings.DB_READONLY)
rank = BackendApi.get_raidevent_rank(cur_eventmaster.id, uid)
self.html_param['raideventscore'] = Objects.raidevent_score(cur_eventmaster, scorerecord, rank)
# 特攻カード.
raideventraidmaster = BackendApi.get_raidevent_raidmaster(model_mgr, cur_eventmaster.id, raidboss.master.id, using=settings.DB_READONLY)
BackendApi.put_raidevent_specialcard_info(self, uid, raideventraidmaster, using=settings.DB_READONLY)
self.html_param['url_raidevent_top'] = self.makeAppLinkUrl(UrlMaker.raidevent_top(cur_eventmaster.id))
self.html_param['is_end'] = is_end
self.writeAppHtml('raidevent/bossappear')
elif is_end:
self.writeAppHtml('raid/helpend')
else:
self.writeAppHtml('raid/helpdetail')
def process(self):
model_mgr = self.getModelMgr()
config = BackendApi.get_current_raideventconfig(model_mgr, using=settings.DB_READONLY)
args = self.getUrlArgs('/raideventtop/')
mid = str(args.get(0))
eventmaster = None
if mid and mid.isdigit():
mid = int(mid)
elif config:
mid = config.mid
if mid:
eventmaster = BackendApi.get_raideventmaster(model_mgr, mid, using=settings.DB_READONLY)
if eventmaster is None:
raise CabaretError(u'Event Closed.', CabaretError.Code.EVENT_CLOSED)
return
cur_eventmaster = self.getCurrentRaidEvent(quiet=True)
mid = eventmaster.id
# 開催中判定.
is_open = cur_eventmaster and cur_eventmaster.id == mid
v_player = self.getViewerPlayer()
uid = v_player.id
scorerecord = BackendApi.get_raidevent_scorerecord(model_mgr, mid, uid, using=settings.DB_READONLY)
flagrecord = BackendApi.get_raidevent_flagrecord(model_mgr, mid, uid, using=settings.DB_READONLY)
# イベント情報.
self.html_param['raidevent'] = Objects.raidevent(self, eventmaster, config)
# 説明とランキングのリンク.
self.putEventTopic(mid, 'top')
if is_open:
# 救援(1件だけ).
func_raidhelp = self.putRaidHelpList(do_execute=False, limit=1)
self.html_param['url_raidhelp_list'] = self.makeAppLinkUrl(UrlMaker.raidevent_helplist())
# 履歴(1件だけ).
raidlogidlist = BackendApi.get_raidlog_idlist(model_mgr, v_player.id, 0, 1, using=settings.DB_READONLY)
raidloglist = BackendApi.get_raidlogs(model_mgr, raidlogidlist, using=settings.DB_READONLY).values()
func_raidlog = BackendApi.put_list_raidlog_obj(self, raidloglist)
self.html_param['url_raidloglist'] = self.makeAppLinkUrl(UrlMaker.raidloglist())
# 発生中のレイド情報.
happeningraidset = self.getHappeningRaidSet()
happeningset = None
if happeningraidset:
happeningset = happeningraidset.happening
if happeningset:
# レイドがある.
if (happeningset.happening.is_cleared() or happeningset.happening.is_missed_and_not_end()):
# 未確認の結果がある.
url = UrlMaker.raidresultanim(happeningset.id)
self.appRedirect(self.makeAppLinkUrlRedirect(url))
return
elif not happeningset.happening.is_end():
obj_happening = Objects.happening(self, happeningraidset)
obj_happening['url_battlepre'] = self.makeAppLinkUrl(UrlMaker.raidevent_battlepre())
self.html_param['happening'] = obj_happening
# デッキ編成へのリンクを上書き.
self.setFromPage(Defines.FromPages.RAIDEVENT)
self.html_param['url_deck_raid'] = self.makeAppLinkUrl(UrlMaker.deck_raid())
elif BackendApi.check_raidevent_lead_epilogue(model_mgr, uid, mid, using=settings.DB_READONLY):
# EDを見ないといけない.
self.appRedirect(self.makeAppLinkUrlRedirect(UrlMaker.raidevent_epilogue()))
return
# 報酬受取り判定.
flag = False
if scorerecord:
if flagrecord is None:
flagrecord = BackendApi.update_raideventflagrecord(model_mgr, eventmaster.id, uid, OSAUtil.get_datetime_max())
if scorerecord.destroy and BackendApi.choice_raidevent_notfixed_destroy_prizeids(eventmaster, scorerecord.destroy, flagrecord, False):
flag = True
elif scorerecord.destroy_big and BackendApi.choice_raidevent_notfixed_destroy_prizeids(eventmaster, scorerecord.destroy_big, flagrecord, True):
flag = True
if flag:
self.html_param['url_raidevent_prizereceive'] = self.makeAppLinkUrl(UrlMaker.raidevent_prizereceive_do(mid, v_player.req_confirmkey))
# イベント秘宝所持数.
# 討伐回数.
rank = BackendApi.get_raidevent_rank(mid, uid)
rank_beginer = BackendApi.get_raidevent_rank(mid, uid, is_beginer=True)
self.html_param['raideventscore'] = Objects.raidevent_score(eventmaster, scorerecord, rank, rank_beginer)
# イベントガチャのリンク.
self.putEventGachaUrl()
# 初心者フラグ.
is_beginer = BackendApi.check_raidevent_beginer(model_mgr, uid, eventmaster, config, using=settings.DB_READONLY)
self.html_param['is_beginer'] = is_beginer
# ランキング.
view_myrank = False
view_beginer = self.request.get(Defines.URLQUERY_BEGINER) == "1"
if not view_beginer or is_beginer:
view_myrank = self.request.get(Defines.URLQUERY_FLAG) == "1"
url_ranking = OSAUtil.addQuery(UrlMaker.raidevent_top(mid), Defines.URLQUERY_FLAG, "0")
url_myrank = OSAUtil.addQuery(UrlMaker.raidevent_top(mid), Defines.URLQUERY_FLAG, "1")
self.putRanking(uid, mid, view_myrank, url_ranking, url_myrank, view_beginer)
# シャンパン.
self.putChampagneData()
# 素材.
self.putMaterialHtml()
# 交換所のURL.
self.putRecipeUrl()
if eventmaster.flag_dedicated_stage:
# イベント専用ステージ情報.
eventstageplaydata = BackendApi.get_raideventstage_playdata(model_mgr, mid, uid, using=settings.DB_READONLY)
# 現在のステージ.
cur_stagemaster = BackendApi.get_current_raideventstage_master(model_mgr, eventmaster, eventstageplaydata, using=settings.DB_READONLY)
if cur_stagemaster is None:
raise CabaretError(u'ステージが存在いません', CabaretError.Code.INVALID_MASTERDATA)
# 現在のステージ情報.
progress = eventstageplaydata.progress
confirmkey = eventstageplaydata.confirmkey
self.html_param['raideventstage'] = Objects.raidevent_stage(self, v_player, cur_stagemaster.stage, cur_stagemaster, progress, confirmkey)
# イベント専用スカウトのTOPページへのリンク.
self.html_param['url_raidevent_scouttop'] = self.makeAppLinkUrl(UrlMaker.raidevent_scouttop())
self.execute_api()
if is_open:
if func_raidhelp:
func_raidhelp()
func_raidlog()
# イベント参加のKPIを保存.
BackendApi.save_kpi_raidevent_join(uid, self.is_pc)
self.writeHtml(eventmaster, 'top')
