def __packHeaderSettings(self, club):
isInStaff = club.hasMember(self.__viewerDbID)
isEnoughPlayers = club.isStaffed()
profile = self.clubsCtrl.getProfile()
limits = self.clubsState.getLimits()
canSendInvite = limits.canSendInvite(profile, club).success
canSeeApplicants = limits.canSeeApplicants(profile, club).success
if isEnoughPlayers:
btnInviteTooltip = TOOLTIPS.STATICFORMATIONSTAFFVIEW_INVITEBTNDIS
else:
btnInviteTooltip = TOOLTIPS.STATICFORMATIONSTAFFVIEW_INVITEBTN
removeBtnVisible = limits.canDestroyClub(profile, club).success or limits.canLeaveClub(profile, club).success
return {
"lblDescriptionVisible": not isInStaff,
"lblStaffedVisible": isEnoughPlayers and isInStaff,
"btnRemoveVisible": removeBtnVisible,
"btnInviteVisible": canSendInvite,
"btnInviteEnable": not isEnoughPlayers,
"showInviteBtnAnimation": not isEnoughPlayers
and AccountSettings.getFilter(SHOW_INVITE_COMMAND_BTN_ANIMATION)
and canSendInvite,
"btnInviteTooltip": btnInviteTooltip,
"isRecruitmentOpened": club.getState().isOpened(),
"btnRecruitmentVisible": canSeeApplicants,
"isCheckBoxPressed": not AccountSettings.getFilter(JOIN_COMMAND_PRESSED),
"cbOpenedVisible": limits.canOpenClub(profile, club).success,
}
def _populateFilters(self, init = False):
vehicles = g_itemsCache.items.getVehicles(REQ_CRITERIA.INVENTORY).values()
filterVehicle = None
if g_currentVehicle.isPresent():
filterVehicle = g_currentVehicle.item.intCD
filter = self._getCurrentFilter()
if filter[1] in (self._MODULE, self._SHELL):
filter = list(AccountSettings.getFilter(self.getName() + '_' + filter[1]))
typeSize = int(filter.pop(0))
filterVehicle = filter[typeSize + 1]
self.__clearSubFilter()
self.__subFilter = {'current': str(filterVehicle),
self._DATA_PROVIDER: []}
vehicles.sort(reverse=True)
for v in vehicles:
filterElement = {'id': str(v.intCD),
'nation': GUI_NATIONS_ORDER_INDEX[nations.NAMES[v.nationID]],
'name': v.userName}
self.__subFilter[self._DATA_PROVIDER].append(filterElement)
if init:
lang, itemType = self._getCurrentFilter()
self.__filterHash.update({'language': lang,
'type': itemType})
self.as_setFilterTypeS(self.__filterHash)
self.as_setSubFilterS(self.__subFilter)
if init:
self._updateFilterOptions(self.__filterHash['type'])
self.as_completeInitS()
return
def initFilters(self):
filters = AccountSettings.getFilter(self.__section)
filters = self._initFilter(**filters)
self._updateFilter(filters['nation'], filters['vehicleType'],
filters['isMain'], filters['level'],
filters['compatibleOnly'])
self.as_setFiltersDataS(filters)
def __getCurrentFilter(self):
"""
Get current tab filters from AccountSettings
:return tuple(nation:<int>, itemType:<str>)
"""
nation, itemType = AccountSettings.getFilter(self.getName() + '_current')
return (nation if nation < len(GUI_NATIONS) else -1, itemType)
def _needToShowAward(self, ctx):
deviceSetting = self.settingsCore.options.getSetting(SOUND.SOUND_DEVICE)
isValid, currentDeviceID = deviceSetting.getSystemState()
if isValid:
return False
lastDeviceID = AccountSettings.getFilter(SPEAKERS_DEVICE)
return False if currentDeviceID == lastDeviceID else True
def _populate(self):
super(BoostersWindow, self)._populate()
self.__tabsContainer.init()
self.__tabsContainer.onTabsUpdate += self.__onTabsUpdate
self.__setFilters(AccountSettings.getFilter(BOOSTERS_FILTER))
self.__setStaticData()
self.__update()
def __init__(self, ctx=None):
super(Barracks, self).__init__()
self.filter = dict(AccountSettings.getFilter(BARRACKS_FILTER))
self.__updateLocationFilter(ctx)
self.__sortedCachedTankmen = None
self.__notRecruitedTankmen = []
return
def _populateFilters(self, init=False):
vehicles = g_itemsCache.items.getVehicles(
REQ_CRITERIA.INVENTORY).values()
filterVehicle = None
if g_currentVehicle.isPresent():
filterVehicle = g_currentVehicle.item.intCD
filter = self._getCurrentFilter()
if filter[1] in (self._MODULE, self._SHELL):
filter = list(
AccountSettings.getFilter(self.getName() + '_' + filter[1]))
typeSize = int(filter.pop(0))
filterVehicle = filter[typeSize + 1]
self.__clearSubFilter()
self.__subFilter = {
'current': str(filterVehicle),
self._DATA_PROVIDER: []
}
vehicles.sort(reverse=True)
for v in vehicles:
filterElement = {
'id': str(v.intCD),
'nation': GUI_NATIONS_ORDER_INDEX[nations.NAMES[v.nationID]],
'name': v.userName
}
self.__subFilter[self._DATA_PROVIDER].append(filterElement)
if init:
lang, itemType = self._getCurrentFilter()
self.__filterHash.update({'language': lang, 'type': itemType})
self.as_setFilterTypeS(self.__filterHash)
self.as_setSubFilterS(self.__subFilter)
if init:
self._updateFilterOptions(self.__filterHash['type'])
self.as_completeInitS()
return
def __switchToMode(self, mode):
if mode != self.__currentMode:
storedValue = AccountSettings.getFilter(FORT_MEMBER_TUTORIAL)
notCommanderHelpShown = storedValue['wasShown']
if self.fortCtrl.getPermissions().canViewNotCommanderHelp() and not notCommanderHelpShown:
self.fireEvent(events.LoadViewEvent(FORTIFICATION_ALIASES.FORT_NOT_COMMANDER_FIRST_ENTER_WINDOW_ALIAS), scope=EVENT_BUS_SCOPE.LOBBY)
AccountSettings.setFilter(FORT_MEMBER_TUTORIAL, {'wasShown': True})
if self.fortCtrl.getFort().isStartingScriptNotStarted() and not self.__commanderHelpShown:
self.as_toggleCommanderHelpS(True)
self.__commanderHelpShown = True
if mode == FORTIFICATION_ALIASES.MODE_COMMON_TUTORIAL:
self.fireEvent(events.LoadViewEvent(FORTIFICATION_ALIASES.FORT_CREATION_CONGRATULATIONS_WINDOW_ALIAS), scope=EVENT_BUS_SCOPE.LOBBY)
self.__makeSystemMessages()
if mode in (FORTIFICATION_ALIASES.MODE_TRANSPORTING_FIRST_STEP,
FORTIFICATION_ALIASES.MODE_TRANSPORTING_NEXT_STEP,
FORTIFICATION_ALIASES.MODE_TRANSPORTING_NOT_AVAILABLE,
FORTIFICATION_ALIASES.MODE_TRANSPORTING_TUTORIAL,
FORTIFICATION_ALIASES.MODE_TRANSPORTING_TUTORIAL_FIRST_STEP,
FORTIFICATION_ALIASES.MODE_TRANSPORTING_TUTORIAL_NEXT_STEP):
g_fortSoundController.setTransportingMode(True)
else:
g_fortSoundController.setTransportingMode(False)
LOG_DEBUG('%s -> %s' % (self.__currentMode, mode))
state = FortificationEffects.STATES[self.__currentMode][mode].copy()
STATE_TEXTS_KEY = 'stateTexts'
if not self.fortCtrl.getPermissions().canTransport():
state['transportToggle'] = FortificationEffects.INVISIBLE
if not self.fortCtrl.getPermissions().canChangeSettings():
state['settingBtn'] = FortificationEffects.INVISIBLE
state[STATE_TEXTS_KEY] = FortificationEffects.TEXTS[mode]
state['mode'] = mode
self.as_switchModeS(state)
self.__currentModeIsDirty = False
self.__currentMode = mode
def _getCustomData(self):
fort = self.fortCtrl.getFort()
level = fort.level
levelTxt = fort_formatters.getTextLevel(level)
defResQuantity = fort.getTotalDefRes()
defResPrefix = text_styles.main(
i18n.makeString(
FORTIFICATIONS.FORTMAINVIEW_COMMON_TOTALDEPOTQUANTITYTEXT))
return {
'clanName':
g_clanCache.clanTag,
'levelTitle':
i18n.makeString(FORTIFICATIONS.FORTMAINVIEW_HEADER_LEVELSLBL,
buildLevel=levelTxt),
'defResText':
defResPrefix + fort_formatters.getDefRes(defResQuantity, True),
'clanProfileBtnLbl':
CLANS.FORT_HEADER_CLANPROFILEBTNLBL,
'clanListBtnTooltip':
makeTooltip(
i18n.makeString(TOOLTIPS.FORTIFICATION_HEADER_CLANLIST_HEADER,
clanName=g_clanCache.clanTag),
i18n.makeString(TOOLTIPS.FORTIFICATION_HEADER_CLANLIST_BODY)),
'orderSelectorVO': {
'isSelected':
AccountSettings.getFilter(ORDERS_FILTER)['isSelected'],
'icon':
RES_ICONS.MAPS_ICONS_LIBRARY_FORTIFICATION_AIM
}
}
def buyTankClick(self):
AccountSettings.setFilter(STORE_TAB, 0)
shopFilter = list(AccountSettings.getFilter('shop_current'))
shopFilter[1] = 'vehicle'
AccountSettings.setFilter('shop_current', tuple(shopFilter))
self.fireEvent(events.LoadViewEvent(VIEW_ALIAS.LOBBY_STORE),
EVENT_BUS_SCOPE.LOBBY)
def configureShopForVehicleTradeIn():
AccountSettings.setFilter('shop_current', (-1, STORE_CONSTANTS.VEHICLE, True))
vehFilter = AccountSettings.getFilter('shop_vehicle')
vehFilter['obtainingType'] = STORE_CONSTANTS.TRADE_IN_VEHICLE
vehFilter['selectedTypes'] = DEFAULT_VEHICLE_TYPES_FILTER
vehFilter['selectedLevels'] = DEFAULT_LEVELS_FILTERS
AccountSettings.setFilter('shop_vehicle', vehFilter)
def _getCustomData(self):
fort = self.fortCtrl.getFort()
level = fort.level
levelTxt = fort_formatters.getTextLevel(level)
defResQuantity = fort.getTotalDefRes()
defResPrefix = text_styles.main(
i18n.makeString(
FORTIFICATIONS.FORTMAINVIEW_COMMON_TOTALDEPOTQUANTITYTEXT))
disabledTransporting = False
if self.__currentMode in (
FORTIFICATION_ALIASES.MODE_TRANSPORTING_FIRST_STEP,
FORTIFICATION_ALIASES.MODE_TRANSPORTING_NEXT_STEP,
FORTIFICATION_ALIASES.MODE_TRANSPORTING_NOT_AVAILABLE):
if not self.fortCtrl.getFort().isTransportationAvailable():
disabledTransporting = True
return {
'clanName':
g_clanCache.clanTag,
'levelTitle':
i18n.makeString(FORTIFICATIONS.FORTMAINVIEW_HEADER_LEVELSLBL,
buildLevel=levelTxt),
'defResText':
defResPrefix + fort_formatters.getDefRes(defResQuantity, True),
'disabledTransporting':
disabledTransporting,
'orderSelectorVO': {
'isSelected':
AccountSettings.getFilter(ORDERS_FILTER)['isSelected'],
'icon':
RES_ICONS.MAPS_ICONS_LIBRARY_FORTIFICATION_AIM
}
}
def _populate(self):
super(BoostersWindow, self)._populate()
self.__tabsContainer.init()
self.__tabsContainer.onTabsUpdate += self.__onTabsUpdate
self.__setFilters(AccountSettings.getFilter(BOOSTERS_FILTER))
self.__setStaticData()
self.__update()
def _getCurrentFilter(self):
outcomeFilter = list(
AccountSettings.getFilter(self.getName() + '_current'))
return [
outcomeFilter[0] if outcomeFilter[0] < len(GUI_NATIONS) else -1,
outcomeFilter[1]
]
def __updateFilterOptions(self, filterType):
"""
Gets vo class name and filter data from AccountSettings by filterType
set this data into Flash and call _update
:param filterType: <str> tab ID
"""
voClassName, showExtra = self._getTabClass(filterType).getFilterInitData()
filters = AccountSettings.getFilter('%s_%s' % (self.getName(), filterType))
data = {'voClassName': voClassName,
'showExtra': showExtra,
'voData': filters}
if filterType in (STORE_CONSTANTS.VEHICLE, STORE_CONSTANTS.RESTORE_VEHICLE, STORE_CONSTANTS.TRADE_IN_VEHICLE):
vehicleTypes = []
levels = []
selectedTypes = filters['selectedTypes']
selectedLevels = filters['selectedLevels']
data['voData'].update({'vehicleTypes': vehicleTypes,
'levels': levels})
for idx, vehicleType in enumerate(VEHICLE_TYPES_ORDER):
vehicleTypes.append({'value': getVehicleTypeAssetPath(vehicleType),
'tooltip': makeTooltip('#menu:carousel_tank_filter/{}'.format(vehicleType), '#tank_carousel_filter:tooltip/vehicleTypes/body'),
'selected': selectedTypes[idx]})
for level in VEHICLE_LEVELS:
levels.append({'value': getLevelsAssetPath('level_{}'.format(level)),
'selected': selectedLevels[level - 1]})
self.as_setFilterOptionsS(data)
self._update()
def __setClanInfo(self, clanInfo):
"""
Sets the clan info.
:param clanInfo: tuple(clanName, clanAbbrev, chatChannelDBID, memberFlags, enteringTime)
:return:
"""
if not isPlayerAccount():
return
else:
name = BigWorld.player().name
if clanInfo and len(clanInfo) > 1:
clanAbbrev = clanInfo[1]
else:
clanAbbrev = None
hasNew = not AccountSettings.getFilter(BOOSTERS)['wasShown']
activeBoosters = self.goodiesCache.getBoosters(
criteria=REQ_CRITERIA.BOOSTER.ACTIVE).values()
hasActiveBooster = len(activeBoosters) > 0
readyBoosters = self.goodiesCache.getBoosters(
criteria=REQ_CRITERIA.BOOSTER.IS_READY_TO_ACTIVATE).values()
boostersAvailable = sum(
(booster.count for booster in readyBoosters))
hasAvailableBoosters = boostersAvailable > 0
boosterIcon, boosterText = (None, None)
if hasActiveBooster:
boosterIcon = RES_ICONS.MAPS_ICONS_BOOSTERS_ACTIVEBOOSTERICON
booster = sorted(activeBoosters,
key=lambda x: x.getUsageLeftTime())[0]
boosterText = booster.getShortLeftTimeStr()
elif hasAvailableBoosters:
boosterIcon = RES_ICONS.MAPS_ICONS_BOOSTERS_AVAILABLEBOOSTERICON
if boostersAvailable <= _MAX_BOOSTERS_TO_DISPLAY:
boosterText = str(boostersAvailable)
else:
boosterText = str(_MAX_BOOSTERS_TO_DISPLAY) + '+'
self.as_nameResponseS({
'userVO': {
'fullName':
self.lobbyContext.getPlayerFullName(name,
clanInfo=clanInfo),
'userName':
name,
'clanAbbrev':
clanAbbrev
},
'isTeamKiller': self.itemsCache.items.stats.isTeamKiller,
'hasNew': hasNew,
'hasActiveBooster': hasActiveBooster,
'hasAvailableBoosters': hasAvailableBoosters,
'tooltip': TOOLTIPS.HEADER_ACCOUNT,
'tooltipType': TOOLTIP_TYPES.COMPLEX,
'boosterIcon': boosterIcon,
'boosterBg': RES_ICONS.MAPS_ICONS_BOOSTERS_ACTIVEBOOSTERBG,
'boosterText': boosterText
})
if g_clanCache.clanDBID:
self.requestClanEmblem16x16(g_clanCache.clanDBID)
self.__updateBadge()
return
def configureShopForVehicleRent():
AccountSettings.setFilter('shop_current', (-1, STORE_CONSTANTS.VEHICLE, True))
vehFilter = AccountSettings.getFilter('shop_vehicle')
vehFilter['obtainingType'] = STORE_CONSTANTS.VEHICLE
vehFilter['selectedTypes'] = DEFAULT_VEHICLE_TYPES_FILTER
vehFilter['selectedLevels'] = DEFAULT_LEVELS_FILTERS
vehFilter['extra'] = [STORE_CONSTANTS.RENTALS_EXTRA_NAME]
AccountSettings.setFilter('shop_vehicle', vehFilter)
def _onTableUpdate(self, *args):
"""
Request table data after update
:param args:
"""
nation, itemType = self.__getCurrentFilter()
filter = AccountSettings.getFilter('%s_%s' % (self.getName(), itemType))
self.requestTableData(nation, itemType, filter)
def _populate(self):
super(BoostersWindow, self)._populate()
self.__setFilters(AccountSettings.getFilter(BOOSTERS_FILTER))
g_clientUpdateManager.addCallbacks({"goodies": self.__onUpdateBoosters})
g_eventsCache.onSyncCompleted += self.__onQuestsUpdate
self.__boosterQuests = self.__getBoosterQuests()
self.__activeBoosters = self.__getActiveBoosters()
self.__update()
self.__setStaticData()
def requestVehicleFilters(self):
filters = AccountSettings.getFilter(self.__section)
filters['isMain'] = False
result = self._initFilter(**filters)
result.update({
'compatibleOnlyLabel':
CYBERSPORT.WINDOW_VEHICLESELECTOR_FILTERS_MATCHES
})
self.as_updateVehicleFiltersS(result)
def configureShopForShells():
AccountSettings.setFilter('shop_current', (-1, STORE_CONSTANTS.SHELL, True))
shellsFilter = AccountSettings.getFilter('shop_shell')
shellsFilter['fitsType'] = STORE_CONSTANTS.OTHER_VEHICLES_SHELL_FIT
shellsFilter['itemTypes'] = [STORE_CONSTANTS.ARMOR_PIERCING_SHELL,
STORE_CONSTANTS.ARMOR_PIERCING_CR_SHELL,
STORE_CONSTANTS.HOLLOW_CHARGE_SHELL,
STORE_CONSTANTS.HIGH_EXPLOSIVE_SHELL]
AccountSettings.setFilter('shop_shell', shellsFilter)
def __onQuestsUpdated(self, *args):
svrEvents = g_eventsCache.getEvents()
quest_settings.updateCommonEventsSettings(svrEvents)
self.as_setDataS({'titleText': QUESTS.QUESTSCONTROL_TITLE,
'tooltip': TOOLTIPS.PRIVATEQUESTS_QUESTCONTROL})
premiumIgrVehiclesQuests = g_eventsCache.getQuests(lambda q: q.getStartTimeLeft() <= 0 < q.getFinishTimeLeft() and q.hasPremIGRVehBonus())
if len(premiumIgrVehiclesQuests):
storedValue = AccountSettings.getFilter(IGR_PROMO)
if not storedValue['wasShown']:
self.fireEvent(events.LoadViewEvent(VIEW_ALIAS.PROMO_PREMIUM_IGR_WINDOW), EVENT_BUS_SCOPE.LOBBY)
def requestTableData(self, nation, actionsSelected, tabID, f):
Waiting.show('updateInventory')
f = flashObject2Dict(f)
itemCD = AccountSettings.getFilter('scroll_to_item')
AccountSettings.setFilter('inventory_current', (nation, tabID, actionsSelected))
AccountSettings.setFilter('inventory_' + tabID, f)
AccountSettings.setFilter('scroll_to_item', None)
self._setTableData(f, nation, tabID, actionsSelected, itemCD)
Waiting.hide('updateInventory')
return
def __onQuestsUpdated(self, *args):
svrEvents = self.eventsCache.getEvents()
quest_settings.updateCommonEventsSettings(svrEvents)
self.as_setDataS({'titleText': QUESTS.QUESTSCONTROL_TITLE,
'tooltip': TOOLTIPS.PRIVATEQUESTS_QUESTCONTROL})
premiumIgrVehiclesQuests = self.eventsCache.getQuests(lambda q: q.getStartTimeLeft() <= 0 < q.getFinishTimeLeft() and q.hasPremIGRVehBonus())
if len(premiumIgrVehiclesQuests):
storedValue = AccountSettings.getFilter(IGR_PROMO)
if not storedValue['wasShown']:
self.fireEvent(events.LoadViewEvent(VIEW_ALIAS.PROMO_PREMIUM_IGR_WINDOW), EVENT_BUS_SCOPE.LOBBY)
def _populate(self):
super(BoostersWindow, self)._populate()
self.__tabsContainer.init()
self.__tabsContainer.onTabsUpdate += self.__onTabsUpdate
self.__setFilters(AccountSettings.getFilter(BOOSTERS_FILTER))
self.__setStaticData()
if self.__defaultTabIdx is None:
self.__defaultTabIdx = self.__getDefaultTabIdx()
self.__tabsContainer.setCurrentTabIdx(self.__defaultTabIdx)
self.__update()
return
def __updateFilterOptions(self, filterType):
"""
Gets vo class name and filter data from AccountSettings by filterType
set this data into Flash and call _update
:param filterType: <str> tab ID
"""
voClassName, showExtra = self._getTabClass(filterType).getFilterInitData()
self.as_setFilterOptionsS({'voClassName': voClassName,
'showExtra': showExtra,
'voData': AccountSettings.getFilter('%s_%s' % (self.getName(), filterType))})
self._update()
def __setClanInfo(self, clanInfo):
name = BigWorld.player().name
if clanInfo and len(clanInfo) > 1:
clanAbbrev = clanInfo[1]
else:
clanAbbrev = None
hasNew = not AccountSettings.getFilter(BOOSTERS)['wasShown']
hasActiveBooster = len(g_goodiesCache.getBoosters(criteria=REQ_CRITERIA.BOOSTER.ACTIVE)) > 0
self.as_nameResponseS(g_lobbyContext.getPlayerFullName(name, clanInfo=clanInfo), name, clanAbbrev, g_itemsCache.items.stats.isTeamKiller, g_clanCache.isInClan, hasNew, hasActiveBooster, TOOLTIPS.HEADER_ACCOUNT, TOOLTIP_TYPES.COMPLEX)
if g_clanCache.clanDBID:
self.requestClanEmblem32x32(g_clanCache.clanDBID)
def _updatePromo(self, promosData):
yield lambda callback: callback(True)
for item in filter(lambda item: item.eventType in (gc_constants.PROMO.TEMPLATE.PATCH, gc_constants.PROMO.TEMPLATE.ACTION), promosData):
promoUrl = yield self.__urlMacros.parse(item.data)
self.__availablePromo.add(promoUrl)
if item.eventType == gc_constants.PROMO.TEMPLATE.PATCH and self.__currentVersionPromoUrl is None:
self.__currentVersionPromoUrl = promoUrl
promoShownSource = AccountSettings.getFilter(PROMO)
self.__promoShown = {url for url in promoShownSource if url in self.__availablePromo}
self.__savePromoShown()
def _populate(self):
super(BoostersWindow, self)._populate()
self.__tabsContainer.init()
self.__tabsContainer.onTabsUpdate += self.__onTabsUpdate
self.__setFilters(AccountSettings.getFilter(BOOSTERS_FILTER))
self.__setStaticData()
if self.__defaultTabIdx is None:
self.__defaultTabIdx = self.__getDefaultTabIdx()
self.__tabsContainer.setCurrentTabIdx(self.__defaultTabIdx)
self.__update()
return
def __init__(self, ctx):
super(NYDecorationsPopover, self).__init__()
self.__slotID = -1
self.__arrowDirection = -1
if 'data' in ctx:
self.__slotID = ctx['data'].slotId
self.__arrowDirection = ctx['data'].arrowDirection
self.__defaultLevel, self.__defaultNation = AccountSettings.getFilterDefault(NY_DECORATIONS_POPOVER_FILTER_1)
self.__filterLevel, self.__filterNation = AccountSettings.getFilter(NY_DECORATIONS_POPOVER_FILTER_1)
self.__toysCount = 0
self.__seenToys = {}
def __packHeaderSettings(self, club):
isInStaff = club.hasMember(self.__viewerDbID)
isEnoughPlayers = club.isStaffed()
profile = self.clubsCtrl.getProfile()
limits = self.clubsState.getLimits()
canSendInvite = limits.canSendInvite(profile, club).success
canSeeApplicants = limits.canSeeApplicants(profile, club).success
if isEnoughPlayers:
btnInviteTooltip = TOOLTIPS.STATICFORMATIONSTAFFVIEW_INVITEBTNDIS
else:
btnInviteTooltip = TOOLTIPS.STATICFORMATIONSTAFFVIEW_INVITEBTN
removeBtnVisible = limits.canDestroyClub(
profile, club).success or limits.canLeaveClub(profile,
club).success
return {
'lblDescriptionVisible':
not isInStaff,
'lblStaffedVisible':
isEnoughPlayers and isInStaff,
'btnRemoveVisible':
removeBtnVisible,
'btnInviteVisible':
canSendInvite,
'btnInviteEnable':
not isEnoughPlayers,
'showInviteBtnAnimation':
not isEnoughPlayers
and AccountSettings.getFilter(SHOW_INVITE_COMMAND_BTN_ANIMATION)
and canSendInvite,
'btnInviteTooltip':
btnInviteTooltip,
'isRecruitmentOpened':
club.getState().isOpened(),
'btnRecruitmentVisible':
canSeeApplicants,
'isCheckBoxPressed':
AccountSettings.getFilter(LAST_CLUB_OPENED_FOR_APPS) !=
self._clubDbID,
'cbOpenedVisible':
limits.canOpenClub(profile, club).success
}
def load(self):
defaultFilters = AccountSettings.getFilterDefaults(self._serverSections)
savedFilters = self.settingsCore.serverSettings.getSections(self._serverSections, defaultFilters)
for section in self._clientSections:
defaultFilters.update(AccountSettings.getFilterDefault(section))
savedFilters.update(AccountSettings.getFilter(section))
self._filters = defaultFilters
for key, value in defaultFilters.iteritems():
savedFilters[key] = type(value)(savedFilters[key])
self.update(savedFilters, save=False)
def _updatePromo(self, promosData):
yield lambda callback: callback(True)
for item in filter(lambda item: item.eventType == gc_constants.PROMO.TEMPLATE.ACTION, promosData):
promoUrl = yield self.__urlMacros.parse(item.data)
self.__availablePromo.add(promoUrl)
if self.__currentVersionPromoUrl is None:
self.__currentVersionPromoUrl = yield self.__urlMacros.parse(GUI_SETTINGS.currentVersionPromo)
promoShownSource = AccountSettings.getFilter(PROMO)
self.__promoShown = {url for url in promoShownSource if url in self.__availablePromo}
self.__savePromoShown()
return
def __switchToMode(self, mode):
if mode != self.__currentMode:
storedValue = AccountSettings.getFilter(FORT_MEMBER_TUTORIAL)
notCommanderHelpShown = storedValue['wasShown']
if self.fortCtrl.getPermissions().canViewNotCommanderHelp(
) and not notCommanderHelpShown:
self.fireEvent(events.LoadViewEvent(
FORTIFICATION_ALIASES.
FORT_NOT_COMMANDER_FIRST_ENTER_WINDOW_ALIAS),
scope=EVENT_BUS_SCOPE.LOBBY)
AccountSettings.setFilter(FORT_MEMBER_TUTORIAL,
{'wasShown': True})
if self.fortCtrl.getFort().isStartingScriptNotStarted(
) and not self.__commanderHelpShown:
self.as_toggleCommanderHelpS(True)
self.__commanderHelpShown = True
if mode == FORTIFICATION_ALIASES.MODE_COMMON_TUTORIAL:
self.fireEvent(events.LoadViewEvent(
FORTIFICATION_ALIASES.
FORT_CREATION_CONGRATULATIONS_WINDOW_ALIAS),
scope=EVENT_BUS_SCOPE.LOBBY)
if self.__currentMode == FORTIFICATION_ALIASES.MODE_DIRECTIONS_TUTORIAL:
self.__makeSystemMessages()
isInTransportingMode = mode in (
FORTIFICATION_ALIASES.MODE_TRANSPORTING_FIRST_STEP,
FORTIFICATION_ALIASES.MODE_TRANSPORTING_NEXT_STEP,
FORTIFICATION_ALIASES.MODE_TRANSPORTING_NOT_AVAILABLE,
FORTIFICATION_ALIASES.MODE_TRANSPORTING_TUTORIAL,
FORTIFICATION_ALIASES.MODE_TRANSPORTING_TUTORIAL_FIRST_STEP,
FORTIFICATION_ALIASES.MODE_TRANSPORTING_TUTORIAL_NEXT_STEP)
self.fireEvent(events.FortEvent(
events.FortEvent.IS_IN_TRANSPORTING_MODE,
ctx={'isInTransportingMode': isInTransportingMode}),
scope=EVENT_BUS_SCOPE.FORT)
LOG_DEBUG('Fort mode has been changed: %s -> %s' %
(self.__currentMode, mode))
state = FortificationEffects.getStates()[
self.__currentMode][mode].copy()
STATE_TEXTS_KEY = 'stateTexts'
if not self.fortCtrl.getPermissions().canTransport():
state['transportToggle'] = FortificationEffects.INVISIBLE
if not self.fortCtrl.getPermissions().canChangeSettings():
state['settingBtn'] = FortificationEffects.INVISIBLE
state[STATE_TEXTS_KEY] = FortificationEffects.TEXTS[mode]
state['mode'] = mode
self.as_switchModeS(state)
self.__currentModeIsDirty = False
self.__currentMode = mode
if self.__defenceHourArrowVisible:
self.__setTutorialArrowToDefenseHourSettingsVisibility()
if self.__intelligenceArrowVisible:
self.__setTutorialArrowToIntelligenceVisibility()
def _getCustomData(self):
fort = self.fortCtrl.getFort()
level = fort.level
levelTxt = fort_formatters.getTextLevel(level)
defResQuantity = fort.getTotalDefRes()
defResPrefix = text_styles.main(i18n.makeString(FORTIFICATIONS.FORTMAINVIEW_COMMON_TOTALDEPOTQUANTITYTEXT))
return {'clanName': g_clanCache.clanTag,
'levelTitle': i18n.makeString(FORTIFICATIONS.FORTMAINVIEW_HEADER_LEVELSLBL, buildLevel=levelTxt),
'defResText': defResPrefix + fort_formatters.getDefRes(defResQuantity, True),
'clanProfileBtnLbl': CLANS.FORT_HEADER_CLANPROFILEBTNLBL,
'clanListBtnTooltip': makeTooltip(i18n.makeString(TOOLTIPS.FORTIFICATION_HEADER_CLANLIST_HEADER, clanName=g_clanCache.clanTag), i18n.makeString(TOOLTIPS.FORTIFICATION_HEADER_CLANLIST_BODY)),
'orderSelectorVO': {'isSelected': AccountSettings.getFilter(ORDERS_FILTER)['isSelected'],
'icon': RES_ICONS.MAPS_ICONS_LIBRARY_FORTIFICATION_AIM}}
def load(self):
defaultFilters = AccountSettings.getFilterDefaults(
self._serverSections)
savedFilters = self._getFromServerStorage(defaultFilters)
for section in self._clientSections:
defaultFilters.update(AccountSettings.getFilterDefault(section))
savedFilters.update(AccountSettings.getFilter(section))
self._filters = defaultFilters
for key, value in defaultFilters.iteritems():
savedFilters[key] = type(value)(savedFilters.get(key, value))
self.update(savedFilters, save=False)
self.newYearReset()
def __packHeaderSettings(self, club):
isInStaff = club.hasMember(self.__viewerDbID)
isEnoughPlayers = club.isStaffed()
profile = self.clubsCtrl.getProfile()
limits = self.clubsState.getLimits()
canSendInvite = limits.canSendInvite(profile, club).success
canSeeApplicants = limits.canSeeApplicants(profile, club).success
if isEnoughPlayers:
btnInviteTooltip = TOOLTIPS.STATICFORMATIONSTAFFVIEW_INVITEBTNDIS
else:
btnInviteTooltip = TOOLTIPS.STATICFORMATIONSTAFFVIEW_INVITEBTN
removeBtnVisible = limits.canDestroyClub(profile, club).success or limits.canLeaveClub(profile, club).success
return {'lblDescriptionVisible': not isInStaff,
'lblStaffedVisible': isEnoughPlayers and isInStaff,
'btnRemoveVisible': removeBtnVisible,
'btnInviteVisible': canSendInvite,
'btnInviteEnable': not isEnoughPlayers,
'showInviteBtnAnimation': not isEnoughPlayers and AccountSettings.getFilter(SHOW_INVITE_COMMAND_BTN_ANIMATION) and canSendInvite,
'btnInviteTooltip': btnInviteTooltip,
'isRecruitmentOpened': club.getState().isOpened(),
'btnRecruitmentVisible': canSeeApplicants,
'isCheckBoxPressed': AccountSettings.getFilter(LAST_CLUB_OPENED_FOR_APPS) != self._clubDbID,
'cbOpenedVisible': limits.canOpenClub(profile, club).success}
def _getCustomData(self):
fort = self.fortCtrl.getFort()
level = fort.level
levelTxt = fort_formatters.getTextLevel(level)
defResQuantity = fort.getTotalDefRes()
defResPrefix = text_styles.main(i18n.makeString(FORTIFICATIONS.FORTMAINVIEW_COMMON_TOTALDEPOTQUANTITYTEXT))
disabledTransporting = False
if self.__currentMode in (FORTIFICATION_ALIASES.MODE_TRANSPORTING_FIRST_STEP, FORTIFICATION_ALIASES.MODE_TRANSPORTING_NEXT_STEP, FORTIFICATION_ALIASES.MODE_TRANSPORTING_NOT_AVAILABLE):
if not self.fortCtrl.getFort().isTransportationAvailable():
disabledTransporting = True
return {'clanName': g_clanCache.clanTag,
'levelTitle': i18n.makeString(FORTIFICATIONS.FORTMAINVIEW_HEADER_LEVELSLBL, buildLevel=levelTxt),
'defResText': defResPrefix + fort_formatters.getDefRes(defResQuantity, True),
'disabledTransporting': disabledTransporting,
'orderSelectorVO': {'isSelected': AccountSettings.getFilter(ORDERS_FILTER)['isSelected'],
'icon': RES_ICONS.MAPS_ICONS_LIBRARY_FORTIFICATION_AIM}}
def __populateFilters(self):
"""
Set filters and subfilters init data into Flash,
call flash update and finalize populate
"""
vehicles = self.__invVehicles
filterVehicle = None
if g_currentVehicle.isPresent():
filterVehicle = g_currentVehicle.item.intCD
nation, itemType, actionsSelected = self.__getCurrentFilter()
if not self._isVehicleRestoreEnabled(
) and itemType == STORE_CONSTANTS.RESTORE_VEHICLE:
itemType = STORE_CONSTANTS.VEHICLE
if not self._isTradeInEnabled(
) and itemType == STORE_CONSTANTS.TRADE_IN_VEHICLE:
itemType = STORE_CONSTANTS.VEHICLE
tabType = itemType
if tabType == STORE_CONSTANTS.RESTORE_VEHICLE:
tabType = STORE_CONSTANTS.VEHICLE
elif tabType == STORE_CONSTANTS.TRADE_IN_VEHICLE:
tabType = STORE_CONSTANTS.VEHICLE
self.__filterHash = {
'language': nation,
'tabType': tabType,
'fittingType': itemType,
'actionsSelected': actionsSelected
}
if itemType in (STORE_CONSTANTS.MODULE, STORE_CONSTANTS.SHELL):
preservedFilters = AccountSettings.getFilter(
'%s_%s' % (self.getName(), itemType))
vehicleCD = preservedFilters['vehicleCD']
if vehicleCD > 0 or filterVehicle is None:
filterVehicle = vehicleCD
self.__subFilter = {'current': filterVehicle, self._DATA_PROVIDER: []}
vehicles.sort(reverse=True)
for v in vehicles:
filterElement = {
'id': str(v.intCD),
'nation': GUI_NATIONS_ORDER_INDEX[nations.NAMES[v.nationID]],
'name': v.userName
}
self.__subFilter[self._DATA_PROVIDER].append(filterElement)
self.as_setFilterTypeS(self.__filterHash)
self.as_setSubFilterS(self.__subFilter)
self.__updateFilterOptions(itemType)
return
def requestTableData(self, nation, actionsSelected, type, filter):
"""
Request table data for selected tab
:param type: <str> tab ID
:param nation: <int> gui nation
:param actionsSelected: <bool> discount's checkbox value
:param filter: <obj> filter data
"""
Waiting.show('updateInventory')
filter = flashObject2Dict(filter)
itemCD = AccountSettings.getFilter('scroll_to_item')
AccountSettings.setFilter('inventory_current',
(nation, type, actionsSelected))
AccountSettings.setFilter('inventory_' + type, filter)
AccountSettings.setFilter('scroll_to_item', None)
self._setTableData(filter, nation, type, actionsSelected, itemCD)
Waiting.hide('updateInventory')
return
def __setClanInfo(self, clanInfo):
if not isPlayerAccount():
return
else:
name = BigWorld.player().name
if clanInfo and len(clanInfo) > 1:
clanAbbrev = clanInfo[1]
else:
clanAbbrev = None
hasNew = not AccountSettings.getFilter(BOOSTERS)['wasShown']
activeBoosters = g_goodiesCache.getBoosters(criteria=REQ_CRITERIA.BOOSTER.ACTIVE).values()
hasActiveBooster = len(activeBoosters) > 0
readyBoosters = g_goodiesCache.getBoosters(criteria=REQ_CRITERIA.BOOSTER.IS_READY_TO_ACTIVATE).values()
boostersAvailable = sum((booster.count for booster in readyBoosters))
hasAvailableBoosters = boostersAvailable > 0
boosterIcon, boosterText = (None, None)
if hasActiveBooster:
boosterIcon = RES_ICONS.MAPS_ICONS_BOOSTERS_ACTIVEBOOSTERICON
booster = sorted(activeBoosters, key=lambda x: x.getUsageLeftTime())[0]
boosterText = booster.getShortLeftTimeStr()
elif hasAvailableBoosters:
boosterIcon = RES_ICONS.MAPS_ICONS_BOOSTERS_AVAILABLEBOOSTERICON
if boostersAvailable <= _MAX_BOOSTERS_TO_DISPLAY:
boosterText = str(boostersAvailable)
else:
boosterText = str(_MAX_BOOSTERS_TO_DISPLAY) + '+'
self.as_nameResponseS({'userVO': {'fullName': g_lobbyContext.getPlayerFullName(name, clanInfo=clanInfo),
'userName': name,
'clanAbbrev': clanAbbrev},
'isTeamKiller': g_itemsCache.items.stats.isTeamKiller,
'hasNew': hasNew,
'hasActiveBooster': hasActiveBooster,
'hasAvailableBoosters': hasAvailableBoosters,
'tooltip': TOOLTIPS.HEADER_ACCOUNT,
'tooltipType': TOOLTIP_TYPES.COMPLEX,
'boosterIcon': boosterIcon,
'boosterBg': RES_ICONS.MAPS_ICONS_BOOSTERS_ACTIVEBOOSTERBG,
'boosterText': boosterText})
if g_clanCache.clanDBID:
self.requestClanEmblem32x32(g_clanCache.clanDBID)
else:
self.as_setClanEmblemS(None)
return
def _updateRallyData(self):
functional = self.unitFunctional
data = vo_converters.makeUnitVO(functional, unitIdx=functional.getUnitIdx(), app=self.app, isFallout=self.__isFallout)
self.as_updateRallyS(data)
falloutFilter = AccountSettings.getFilter(FALLOUT)
wasShown = falloutFilter['wasShown']
isNew = False
isEventEnabled = g_eventsCache.isEventEnabled()
if isEventEnabled:
battleTypeName = i18n.makeString(MENU.HEADERBUTTONS_BATTLE_MENU_STANDART) + '\n' + i18n.makeString(MENU.HEADERBUTTONS_BATTLE_MENU_DOMINATION)
tooltipStr = makeTooltip(body=TOOLTIPS.SQUADWINDOW_EVENT_DOMINATION, note=alert(i18n.makeString(TOOLTIPS.SQUADWINDOW_EVENT_DOMINATION_NOTE, vehicles=self._getEventVehiclesNamesStr())))
isNew = not wasShown
else:
battleTypeName = i18n.makeString(MENU.HEADERBUTTONS_BATTLE_MENU_STANDART)
tooltipStr = ''
self.as_updateBattleTypeInfoS(tooltipStr, isEventEnabled)
self.as_updateBattleTypeS(battleTypeName, isEventEnabled, isNew)
if isNew:
falloutFilter['wasShown'] = True
AccountSettings.setFilter(FALLOUT, falloutFilter)
def __onQuestsUpdated(self, *args):
svrEvents = g_eventsCache.getEvents()
quest_settings.updateCommonEventsSettings(svrEvents)
btnInfo = _createBtnInfo(QUESTS.QUESTSCONTROL_ADDITIONALTITLE_EMPTY, TOOLTIPS.PRIVATEQUESTS_QUESTCONTROL_EMPTY, highlight=False)
if isPotapovQuestEnabled():
if not quest_settings.isNeedToShowHeaderAlert():
quest_settings.markHeaderAlertAsVisited()
btnInfo = _createBtnInfo(QUESTS.QUESTSCONTROL_ADDITIONALTITLE_FIRSTRUN, TOOLTIPS.PRIVATEQUESTS_QUESTCONTROL_NEW)
elif g_eventsCache.potapov.hasQuestsForReward():
btnInfo = _createBtnInfo(QUESTS.QUESTSCONTROL_ADDITIONALTITLE_NEEDRECEIVEDAWARD, TOOLTIPS.PRIVATEQUESTS_QUESTCONTROL_RECEIVETHEAWARD, alert=True)
elif g_eventsCache.potapov.hasQuestsForSelect():
btnInfo = _createBtnInfo(QUESTS.QUESTSCONTROL_ADDITIONALTITLE_FREESLOTSANDFREEQUESTS, TOOLTIPS.PRIVATEQUESTS_QUESTCONTROL_AVAILABLE, alert=True)
self.as_setDataS({'titleText': QUESTS.QUESTSCONTROL_TITLE,
'additionalText': text_styles.alert(i18n.makeString(btnInfo.text)),
'tooltip': btnInfo.tooltip})
self.as_isShowAlertIconS(btnInfo.alert, btnInfo.highlight)
premiumIgrVehiclesQuests = g_eventsCache.getQuests(lambda q: q.getStartTimeLeft() <= 0 < q.getFinishTimeLeft() and q.hasPremIGRVehBonus())
if len(premiumIgrVehiclesQuests):
storedValue = AccountSettings.getFilter(IGR_PROMO)
if not storedValue['wasShown']:
self.fireEvent(events.LoadViewEvent(VIEW_ALIAS.PROMO_PREMIUM_IGR_WINDOW))
def __switchToMode(self, mode):
if mode != self.__currentMode:
storedValue = AccountSettings.getFilter(FORT_MEMBER_TUTORIAL)
notCommanderHelpShown = storedValue['wasShown']
if self.fortCtrl.getPermissions().canViewNotCommanderHelp() and not notCommanderHelpShown:
self.fireEvent(events.LoadViewEvent(FORTIFICATION_ALIASES.FORT_NOT_COMMANDER_FIRST_ENTER_WINDOW_ALIAS), scope=EVENT_BUS_SCOPE.LOBBY)
AccountSettings.setFilter(FORT_MEMBER_TUTORIAL, {'wasShown': True})
if self.fortCtrl.getFort().isStartingScriptNotStarted() and not self.__commanderHelpShown:
self.as_toggleCommanderHelpS(True)
self.__commanderHelpShown = True
if mode == FORTIFICATION_ALIASES.MODE_COMMON_TUTORIAL:
self.fireEvent(events.LoadViewEvent(FORTIFICATION_ALIASES.FORT_CREATION_CONGRATULATIONS_WINDOW_ALIAS), scope=EVENT_BUS_SCOPE.LOBBY)
if self.__currentMode == FORTIFICATION_ALIASES.MODE_DIRECTIONS_TUTORIAL:
self.__makeSystemMessages()
isInTransportingMode = mode in (FORTIFICATION_ALIASES.MODE_TRANSPORTING_FIRST_STEP,
FORTIFICATION_ALIASES.MODE_TRANSPORTING_NEXT_STEP,
FORTIFICATION_ALIASES.MODE_TRANSPORTING_NOT_AVAILABLE,
FORTIFICATION_ALIASES.MODE_TRANSPORTING_TUTORIAL,
FORTIFICATION_ALIASES.MODE_TRANSPORTING_TUTORIAL_FIRST_STEP,
FORTIFICATION_ALIASES.MODE_TRANSPORTING_TUTORIAL_NEXT_STEP)
self.fireEvent(events.FortEvent(events.FortEvent.IS_IN_TRANSPORTING_MODE, ctx={'isInTransportingMode': isInTransportingMode}), scope=EVENT_BUS_SCOPE.FORT)
LOG_DEBUG('Fort mode has been changed: %s -> %s' % (self.__currentMode, mode))
state = FortificationEffects.getStates()[self.__currentMode][mode].copy()
STATE_TEXTS_KEY = 'stateTexts'
if not self.fortCtrl.getPermissions().canTransport():
state['transportToggle'] = FortificationEffects.INVISIBLE
if not self.fortCtrl.getPermissions().canChangeSettings():
state['settingBtn'] = FortificationEffects.INVISIBLE
state[STATE_TEXTS_KEY] = FortificationEffects.TEXTS[mode]
state['mode'] = mode
self.as_switchModeS(state)
self.__currentModeIsDirty = False
self.__currentMode = mode
if self.__defenceHourArrowVisible:
self.__setTutorialArrowToDefenseHourSettingsVisibility()
if self.__intelligenceArrowVisible:
self.__setTutorialArrowToIntelligenceVisibility()
def _populateFilters(self, init = False):
vehicles = yield Requester(self._VEHICLE).getFromInventory()
oldStyleVehicle = None
for v in vehicles:
if v.inventoryId == g_currentVehicle.invID:
oldStyleVehicle = v
break
filterVehicle = None
if g_currentVehicle.isPresent():
filterVehicle = compactItem(oldStyleVehicle)
filter = self._getCurrentFilter()
if filter[1] in (self._MODULE, self._SHELL):
filter = list(AccountSettings.getFilter(self.getName() + '_' + filter[1]))
typeSize = int(filter.pop(0))
filterVehicle = filter[typeSize + 1]
self.__clearSubFilter()
self.__subFilter = {'current': filterVehicle,
self._DATA_PROVIDER: []}
vehicles.sort(reverse=True)
for v in vehicles:
filterElement = {'id': compactItem(v),
'nation': GUI_NATIONS_ORDER_INDEX[nations.NAMES[v.nation]],
'name': v.name}
self.__subFilter[self._DATA_PROVIDER].append(filterElement)
if init:
lang, itemType = self._getCurrentFilter()
self.__filterHash.update({'language': lang,
'type': itemType})
self.as_setFilterTypeS(self.__filterHash)
self.as_setSubFilterS(self.__subFilter)
if init:
self._updateFilterOptions(self.__filterHash['type'])
self.as_completeInitS()
return
def onSelectOrderSelector(self, value):
filters = AccountSettings.getFilter(ORDERS_FILTER)
filters['isSelected'] = value
AccountSettings.setFilter(ORDERS_FILTER, filters)
def initFilters(self):
filters = AccountSettings.getFilter(self.__section)
filters = self._initFilter(**filters)
self._updateFilter(filters['nation'], filters['vehicleType'], filters['isMain'], filters['level'], filters['compatibleOnly'])
self.as_setFiltersDataS(filters)
def __init__(self, ctx = None):
super(Barracks, self).__init__()
self.filter = dict(AccountSettings.getFilter(BARRACKS_FILTER))
def buyTankClick(self):
shopFilter = list(AccountSettings.getFilter('shop_current'))
shopFilter[1] = 'vehicle'
AccountSettings.setFilter('shop_current', tuple(shopFilter))
self.fireEvent(events.LoadEvent(events.LoadEvent.LOAD_SHOP), EVENT_BUS_SCOPE.LOBBY)
def _getCurrentFilter(self):
outcomeFilter = list(AccountSettings.getFilter(self.getName() + '_current'))
return [outcomeFilter[0] if outcomeFilter[0] < len(GUI_NATIONS) else -1, outcomeFilter[1]]
def requestVehicleFilters(self):
filters = AccountSettings.getFilter(self.__section)
filters['isMain'] = False
result = self._initFilter(**filters)
self.as_updateVehicleFiltersS(result)
def _onTableUpdate(self, *args):
params = self._getCurrentFilter()
filter = AccountSettings.getFilter(self.getName() + '_' + params[1])
self.requestTableData(params[0], params[1], filter)
def getFilterData(self):
filters = AccountSettings.getFilter(self.__section)
filters['isMain'] = False
result = self._initFilter(**filters)
return result
def buyTankClick(self):
AccountSettings.setFilter(STORE_TAB, 0)
shopFilter = list(AccountSettings.getFilter('shop_current'))
shopFilter[1] = 'vehicle'
AccountSettings.setFilter('shop_current', tuple(shopFilter))
self.fireEvent(events.LoadViewEvent(VIEW_ALIAS.LOBBY_STORE), EVENT_BUS_SCOPE.LOBBY)
def isChanged(self, value):
return value != AccountSettings.getFilter(AWARDS).get(self.__key)
def isTimeToShowGoldFishPromo():
return getCurrentTimestamp() - AccountSettings.getFilter(GOLD_FISH_LAST_SHOW_TIME) >= GUI_SETTINGS.goldFishActionShowCooldown
def __setNewValue(self, value):
achievement = AccountSettings.getFilter(AWARDS)
achievement[self.__key] = value
AccountSettings.setFilter(AWARDS, achievement)
def _updateFilterOptions(self, filterType):
mf = AccountSettings.getFilter(self.getName() + '_' + filterType)
self.as_setFilterOptionsS(mf)
self._update()
