def __init__(self, intCompactDescr, proxy=None, isBoughtForAltPrice=False):
"""
Ctr.
:param intCompactDescr: item's int compact descriptor
:param proxy: instance of ItemsRequester
:param isBoughtForAltPrice: indicates whether the item has been bought for credits(alt price)
"""
GUIItem.__init__(self, proxy)
HasIntCD.__init__(self, intCompactDescr)
self._isBoughtForAltPrice = isBoughtForAltPrice
self._rentInfo = RentalInfoProvider()
self._restoreInfo = None
self._personalDiscountPrice = None
if proxy is not None and proxy.inventory.isSynced(
) and proxy.stats.isSynced() and proxy.shop.isSynced():
self._mayConsumeWalletResources = proxy.stats.mayConsumeWalletResources
defaultPrice = proxy.shop.defaults.getItemPrice(self.intCD)
if defaultPrice is None:
defaultPrice = MONEY_UNDEFINED
buyPrice, self._isHidden = proxy.shop.getItem(self.intCD)
if buyPrice is None:
buyPrice = MONEY_UNDEFINED
altPrice = self._getAltPrice(buyPrice, proxy.shop)
defaultAltPrice = self._getAltPrice(defaultPrice,
proxy.shop.defaults)
self._buyPrices = ItemPrices(
itemPrice=ItemPrice(price=buyPrice, defPrice=defaultPrice),
itemAltPrice=ItemPrice(price=altPrice,
defPrice=defaultAltPrice))
defaultSellPrice = Money.makeFromMoneyTuple(
BigWorld.player().shop.getSellPrice(
defaultPrice,
proxy.shop.defaults.sellPriceModifiers(intCompactDescr),
self.itemTypeID))
sellPrice = Money.makeFromMoneyTuple(
BigWorld.player().shop.getSellPrice(
buyPrice, proxy.shop.sellPriceModifiers(intCompactDescr),
self.itemTypeID))
self._sellPrices = ItemPrices(itemPrice=ItemPrice(
price=sellPrice, defPrice=defaultSellPrice),
itemAltPrice=ITEM_PRICE_EMPTY)
self._inventoryCount = proxy.inventory.getItems(
self.itemTypeID, self.intCD)
if self._inventoryCount is None:
self._inventoryCount = 0
self._isUnlocked = self.intCD in proxy.stats.unlocks
self._isInitiallyUnlocked = self.intCD in proxy.stats.initialUnlocks
self._fullyConfigured = True
else:
self._buyPrices = ITEM_PRICES_EMPTY
self._sellPrices = ITEM_PRICES_EMPTY
self._isHidden = False
self._inventoryCount = 0
self._isUnlocked = False
self._mayConsumeWalletResources = False
self._isInitiallyUnlocked = False
self._fullyConfigured = False
return
def __init__(self,
intCompactDescr,
proxy=None,
isBoughtForAltPrice=False,
strCD=None):
super(FittingItem, self).__init__(intCD=HasIntCD(intCompactDescr),
strCD=strCD)
self._isBoughtForAltPrice = isBoughtForAltPrice
self._rentInfo = RentalInfoProvider(None, None, None, None, None, None)
self._restoreInfo = None
self._personalDiscountPrice = None
self._descriptor = self._getDescriptor()
if proxy is not None and proxy.inventory.isSynced(
) and proxy.stats.isSynced() and proxy.shop.isSynced():
self._mayConsumeWalletResources = proxy.stats.mayConsumeWalletResources
defaultPrice = proxy.shop.defaults.getItemPrice(self.intCD)
if defaultPrice is None:
defaultPrice = MONEY_UNDEFINED
buyPrice, self._isHidden = proxy.shop.getItem(self.intCD)
if buyPrice is None:
buyPrice = MONEY_UNDEFINED
altPrice = self._getAltPrice(buyPrice, proxy.shop)
defaultAltPrice = self._getAltPrice(defaultPrice,
proxy.shop.defaults)
self._buyPrices = ItemPrices(
itemPrice=ItemPrice(price=buyPrice, defPrice=defaultPrice),
itemAltPrice=ItemPrice(price=altPrice,
defPrice=defaultAltPrice))
defaultSellPrice = Money.makeFromMoneyTuple(
BigWorld.player().shop.getSellPrice(
defaultPrice,
proxy.shop.defaults.sellPriceModifiers(intCompactDescr),
self.itemTypeID))
sellPrice = Money.makeFromMoneyTuple(
BigWorld.player().shop.getSellPrice(
buyPrice, proxy.shop.sellPriceModifiers(intCompactDescr),
self.itemTypeID))
self._sellPrices = ItemPrices(itemPrice=ItemPrice(
price=sellPrice, defPrice=defaultSellPrice),
itemAltPrice=ITEM_PRICE_EMPTY)
self._inventoryCount = proxy.inventory.getItems(
self.itemTypeID, self.intCD)
if self._inventoryCount is None:
self._inventoryCount = 0
self._isUnlocked = self.intCD in proxy.stats.unlocks
self._isInitiallyUnlocked = self.intCD in proxy.stats.initialUnlocks
self._fullyConfigured = True
else:
self._buyPrices = ITEM_PRICES_EMPTY
self._sellPrices = ITEM_PRICES_EMPTY
self._isHidden = False
self._inventoryCount = 0
self._isUnlocked = False
self._mayConsumeWalletResources = False
self._isInitiallyUnlocked = False
self._fullyConfigured = False
return
def getRemovalPrice(self, proxy=None):
if not self.isRemovable and proxy is not None:
if self.isDeluxe():
cost = proxy.shop.paidDeluxeRemovalCost
defaultCost = proxy.shop.defaults.paidDeluxeRemovalCost
return ItemPrice(price=cost, defPrice=defaultCost)
cost = proxy.shop.paidRemovalCost
defaultCost = proxy.shop.defaults.paidRemovalCost
return ItemPrice(price=Money(gold=cost), defPrice=Money(gold=defaultCost))
else:
return super(OptionalDevice, self).getRemovalPrice(proxy)
def __init__(self, boosterID, boosterDescription, proxy):
super(Booster, self).__init__(boosterID, boosterDescription, proxy)
buyPrice, defaultPrice, altPrice, defaultAltPrice, self.isHidden = proxy.getBoosterPriceData(boosterID)
buyPrice = ItemPrice(price=buyPrice, defPrice=defaultPrice)
if altPrice is not None:
altPrice = ItemPrice(price=altPrice, defPrice=defaultAltPrice)
else:
altPrice = ITEM_PRICE_EMPTY
self.__buyPrices = ItemPrices(itemPrice=buyPrice, itemAltPrice=altPrice)
self.__sellPrices = ITEM_PRICES_EMPTY
self.__activeBoostersValues = proxy.getActiveBoostersTypes()
return
def getStylePurchaseItems(style, modifiedOutfits, c11nService=None, prolongRent=False, progressionLevel=-1):
purchaseItems = []
vehicle = g_currentVehicle.item
vehicleCD = vehicle.descriptor.makeCompactDescr()
isStyleInstalled = c11nService.getCurrentOutfit(SeasonType.SUMMER).id == style.id
inventoryCounts = __getInventoryCounts(modifiedOutfits, vehicleCD)
styleCount = style.fullInventoryCount(vehicle.intCD)
isFromInventory = not prolongRent and (styleCount > 0 or isStyleInstalled)
if style.isProgressive:
totalPrice = ItemPrice(Money(), Money())
currentProgressionLvl = style.getLatestOpenedProgressionLevel(vehicle)
progressivePrice = style.getUpgradePrice(currentProgressionLvl, progressionLevel)
if style.isProgressionPurchasable(progressionLevel):
totalPrice = progressivePrice
if not style.isHidden and not isFromInventory:
totalPrice += style.getBuyPrice()
isFromInventory = False if progressionLevel > currentProgressionLvl else isFromInventory
purchaseItem = PurchaseItem(style, totalPrice, areaID=None, slotType=None, regionIdx=None, selected=True, group=AdditionalPurchaseGroups.STYLES_GROUP_ID, isFromInventory=isFromInventory, locked=True, progressionLevel=progressionLevel)
purchaseItems.append(purchaseItem)
else:
purchaseItem = PurchaseItem(style, style.getBuyPrice(), areaID=None, slotType=None, regionIdx=None, selected=True, group=AdditionalPurchaseGroups.STYLES_GROUP_ID, isFromInventory=isFromInventory, locked=True)
purchaseItems.append(purchaseItem)
for season in SeasonType.COMMON_SEASONS:
modifiedOutfit = modifiedOutfits[season]
if style.isProgressive:
modifiedOutfit = c11nService.removeAdditionalProgressionData(outfit=modifiedOutfit, style=style, vehCD=vehicleCD, season=season)
baseOutfit = style.getOutfit(season, vehicleCD)
for intCD, component, regionIdx, container, _ in modifiedOutfit.itemsFull():
item = c11nService.getItemByCD(intCD)
itemTypeID = item.itemTypeID
slotType = ITEM_TYPE_TO_SLOT_TYPE.get(itemTypeID)
if slotType is None:
continue
slotId = C11nId(container.getAreaID(), slotType, regionIdx)
modifiedSlotData = SlotData(intCD, component)
baseSlotData = getSlotDataFromSlot(baseOutfit, slotId)
isEdited = baseSlotData.intCD != modifiedSlotData.intCD
if isEdited:
if slotId != correctSlot(slotId):
continue
price = item.getBuyPrice()
isFromInventory = inventoryCounts[intCD] > 0 or item.isStyleOnly
locked = bool(style.getDependenciesIntCDs()) and itemTypeID in EDITABLE_STYLE_IRREMOVABLE_TYPES and itemTypeID != GUI_ITEM_TYPE.CAMOUFLAGE
else:
price = ItemPrice(Money(credits=0), Money())
isFromInventory = True
locked = isPurchaseItemLocked(item, style)
purchaseItem = PurchaseItem(item, price=price, areaID=slotId.areaId, slotType=slotId.slotType, regionIdx=slotId.regionIdx, selected=True, group=season, isFromInventory=isFromInventory, component=component, locked=locked, isEdited=isEdited)
purchaseItems.append(purchaseItem)
inventoryCounts[intCD] -= 1
return purchaseItems
def __buildPrice(self):
if not self._stateProvider:
return
else:
priceData = self._stateProvider.getBoosterPriceData(self.boosterID)
buyPrice, defaultPrice, altPrice, defaultAltPrice = priceData
buyPrice = ItemPrice(price=buyPrice, defPrice=defaultPrice)
if altPrice is not None:
altPrice = ItemPrice(price=altPrice, defPrice=defaultAltPrice)
else:
altPrice = ITEM_PRICE_EMPTY
self.__buyPrices = ItemPrices(itemPrice=buyPrice,
itemAltPrice=altPrice)
return
def __getTotalItemPrice(self):
price = defPrice = ZERO_MONEY
if self.__isTradeIn(
) and self.__tradeOffVehicle is not None and not self.__isRentVisible:
tradeInPrice = self.__tradeIn.getTradeInPrice(self.__vehicle)
price = tradeInPrice.price
defPrice = tradeInPrice.defPrice
elif self.__selectedRentIdx >= 0 and self.__isRentVisible:
price += self.__vehicle.rentPackages[
self.__selectedRentIdx]['rentPrice']
elif self.viewModel.getIsRestore():
price += self.__vehicle.restorePrice
else:
price += self.__vehicle.buyPrices.itemPrice.price
defPrice += self.__vehicle.buyPrices.itemPrice.defPrice
if not self.__isWithoutCommander:
commanderCardsPrices = self.__shop.getTankmanCostItemPrices()
commanderItemPrice = commanderCardsPrices[self.__selectedCardIdx]
commanderItemPrice *= len(self.__vehicle.crew)
price += commanderItemPrice.price
if self.viewModel.equipmentBlock.slot.getIsSelected():
vehSlots = self.__stats.vehicleSlots
price += self.__shop.getVehicleSlotsItemPrice(vehSlots).price
if self.viewModel.equipmentBlock.ammo.getIsSelected():
price += self.__getAmmoItemPrice().price
if defPrice is ZERO_MONEY:
defPrice = price
return ItemPrice(price=price, defPrice=defPrice)
def __setTotalData(self, *_):
cart = getTotalPurchaseInfo(self._purchaseItems)
totalPriceVO = getItemPricesVO(cart.totalPrice)
state = g_currentVehicle.getViewState()
shortage = self.itemsCache.items.stats.money.getShortage(
cart.totalPrice.price)
inFormationAlert = ''
if not state.isCustomizationEnabled():
inFormationAlert = text_styles.concatStylesWithSpace(
icons.markerBlocked(),
text_styles.error(
VEHICLE_CUSTOMIZATION.WINDOW_PURCHASE_FORMATION_ALERT))
self.as_setTotalDataS({
'totalLabel':
text_styles.highTitle(
_ms(VEHICLE_CUSTOMIZATION.WINDOW_PURCHASE_TOTALCOST,
selected=cart.numSelected,
total=cart.numApplying)),
'enoughMoney':
getItemPricesVO(ItemPrice(shortage, shortage))[0],
'inFormationAlert':
inFormationAlert,
'totalPrice':
totalPriceVO[0]
})
def _getSlotPrice(self):
shop = self.itemsCache.items.shop
stats = self.itemsCache.items.stats
price = Money(gold=shop.getVehicleSlotsPrice(stats.vehicleSlots))
defPrice = Money(
gold=shop.defaults.getVehicleSlotsPrice(stats.vehicleSlots))
return ItemPrice(price, defPrice)
def _getCrewPrice(self):
if self.__state.crewType != -1:
shop = self.itemsCache.items.shop
costs = (shop.tankmanCostWithGoodyDiscount[self.__state.crewType], shop.defaults.tankmanCost[self.__state.crewType])
tankmanCount = len(self.vehicle.crew)
return ItemPrice(*[ Money(gold=cost[Currency.GOLD], credits=cost[Currency.CREDITS]) for cost in costs ]) * tankmanCount
return ITEM_PRICE_EMPTY
def getTankmanCostItemPrices(self):
result = []
defaultCost = self.defaults.tankmanCost
countItems = len(defaultCost)
if countItems == len(self.tankmanCostWithGoodyDiscount):
for idx in xrange(countItems):
commanderLevelsPrices = {}
commanderLevelsDefPrices = {}
for currency in Currency.ALL:
defPriceCurrency = defaultCost[idx].get(currency, None)
if defPriceCurrency:
commanderLevelsPrices[
currency] = self.tankmanCostWithGoodyDiscount[
idx].get(currency, None)
commanderLevelsDefPrices[currency] = defPriceCurrency
price = Money(**commanderLevelsPrices)
defPrice = Money(**commanderLevelsDefPrices)
itemPrice = ItemPrice(price=price, defPrice=defPrice)
result.append(itemPrice)
else:
_logger.error(
'len(self.tankmanCost) must be equal to len(self.tankmanCostWithGoodyDiscount)'
)
return result
def _getVehiclePrice(self, vehicle):
if self.__state.rentID == -1:
return vehicle.buyPrices.itemPrice
rentPackage = vehicle.rentPackages[self.__state.rentID]
price, defPrice = rentPackage['rentPrice'], rentPackage[
'defaultRentPrice']
return ItemPrice(price, defPrice)
def __init__(self, boosterID, boosterDescription, proxy):
super(Booster, self).__init__(boosterID, boosterDescription, proxy)
if not boosterDescription.variety == GOODIE_VARIETY.BOOSTER:
raise AssertionError
buyPrice, defaultPrice, altPrice, defaultAltPrice, self.isHidden = proxy.getBoosterPriceData(
boosterID)
buyPrice = ItemPrice(price=buyPrice, defPrice=defaultPrice)
altPrice = altPrice is not None and ItemPrice(
price=altPrice, defPrice=defaultAltPrice)
else:
altPrice = ITEM_PRICE_EMPTY
self.__buyPrices = ItemPrices(itemPrice=buyPrice,
itemAltPrice=altPrice)
self.__sellPrices = ITEM_PRICES_EMPTY
self.__activeBoostersValues = proxy.getActiveBoostersTypes()
return
def _getLevelPrice(level):
levelDescr = self.descriptor.progression.levels.get(level)
if levelDescr is not None:
price = Money(**levelDescr['price'])
return ItemPrice(price=price, defPrice=price)
else:
return ITEM_PRICE_EMPTY
def _initialize(self, *args, **kwargs):
super(BuyVehicleView, self)._initialize()
self._blur = GUI.WGUIBackgroundBlur()
self._blur.enable = True
self.__addListeners()
isElite = self.__vehicle.isElite
vehType = self.__vehicle.type.replace('-', '_')
isRestoreAvailable = self.__vehicle.isRestoreAvailable()
with self.viewModel.transaction() as model:
model.setTankType(
'{}_elite'.format(vehType) if isElite else vehType)
vehicleTooltip = i18n.makeString(
getTypeUserName(self.__vehicle.type, isElite))
noCrewLabelPath = R.strings.store.buyVehicleWindow.checkBox
model.setVehicleNameTooltip(vehicleTooltip)
model.setNation(nations.NAMES[self.__vehicle.nationID])
model.setNoCrewCheckboxLabel(
noCrewLabelPath.restore.withoutCrew
if isRestoreAvailable else noCrewLabelPath.buy.withoutCrew)
model.setTankLvl(int2roman(self.__vehicle.level))
model.setTankName(self.__vehicle.shortUserName)
model.setCountCrew(len(self.__vehicle.crew))
model.setBuyVehicleIntCD(self.__vehicle.intCD)
model.setIsToggleBtnVisible(self.__isTradeIn()
and self.__vehicle.hasRentPackages)
model.setIsElite(isElite)
model.setIsRentVisible(self.__isRentVisible)
model.setIsInBootcamp(self.__isBootcampBuyVehicle())
model.setIsMovingTextEnabled(constants.IS_CHINA
and GUI_SETTINGS.movingText.show)
if self.__vehicle.hasCrew:
model.setWithoutCommanderAltText(
R.strings.store.buyVehicleWindow.crewInVehicle)
equipmentBlock = model.equipmentBlock
equipmentBlock.setIsRentVisible(self.__isRentVisible)
equipmentBlock.setTradeInIsEnabled(self.__isTradeIn())
emtySlotAvailable = self.itemsCache.items.inventory.getFreeSlots(
self.__stats.vehicleSlots) > 0
equipmentBlock.setEmtySlotAvailable(emtySlotAvailable)
equipmentBlock.setIsRestore(isRestoreAvailable)
if self.__vehicle.hasRentPackages and not isRestoreAvailable:
self.__selectedRentIdx = 0
self.__selectedRentTerm = self.__vehicle.rentPackages[
self.__selectedRentIdx]['days']
tankPriceArray = model.tankPrice.getItems()
self.__addVMsInActionPriceList(tankPriceArray,
self.__vehicle.buyPrices.itemPrice)
self.__updateTankPrice()
self.__updateCommanderCards()
self.__updateSlotPrice()
self.__updateAmmoPrice()
self.__updateTradeInInfo()
self.__updateRentInfo()
self.__updateBuyBtnLabel()
totalPriceArray = equipmentBlock.totalPrice.getItems()
self.__addVMsInActionPriceList(
totalPriceArray,
ItemPrice(price=Money(credits=0, gold=0),
defPrice=Money(credits=0, gold=0)))
self.__updateTotalPrice()
def __makeVehiclePurchaseVO(self, item, unlockProps, price):
return {'title': _ms(BATTLE_RESULTS.COMMON_VEHICLE_PURCHASE),
'description': self.__makeVehicleDescription(item),
'vehicleIcon': item.iconSmall,
'lvlIcon': getLevelIconPath(item.level),
'price': getItemPricesVO(ItemPrice(price=price, defPrice=price)),
'linkEvent': PROGRESS_ACTION.PURCHASE_UNLOCK_TYPE,
'linkId': unlockProps.parentID}
def getRemovalPrice(self, proxy=None):
"""
The price to remove this device from vehicle
:param proxy: instance of ItemsRequester
:return: ItemPrice
"""
if not self.isRemovable and proxy is not None:
if self.isDeluxe():
cost = proxy.shop.paidDeluxeRemovalCost
defaultCost = proxy.shop.defaults.paidDeluxeRemovalCost
return ItemPrice(price=cost, defPrice=defaultCost)
else:
cost = proxy.shop.paidRemovalCost
defaultCost = proxy.shop.defaults.paidRemovalCost
return ItemPrice(price=Money(gold=cost),
defPrice=Money(gold=defaultCost))
return super(OptionalDevice, self).getRemovalPrice(proxy)
def __getConversionPrice(self, xp):
def computeCost(xp, rate, cost):
return round(cost * xp / rate)
rate, cost = self.itemsCache.items.shop.freeXPConversionWithDiscount
defRate, defCost = self.itemsCache.items.shop.defaults.freeXPConversion
return ItemPrice(Money(gold=computeCost(xp, rate, cost)),
Money(gold=computeCost(xp, defRate, defCost)))
def getVehicleSlotsItemPrice(self, currentSlotsCount):
defPrice = self.defaults.getVehicleSlotsPrice(currentSlotsCount)
price = self.getVehicleSlotsPrice(currentSlotsCount)
slotGoodies = self.personalSlotDiscounts
if slotGoodies:
bestGoody = self.bestGoody(slotGoodies)
price = getPriceWithDiscount(price, bestGoody.resource)
return ItemPrice(price=Money.makeFrom(Currency.GOLD, price), defPrice=Money.makeFrom(Currency.GOLD, defPrice))
def __makeModulePurchaseVO(self, item, unlockProps, price):
return {'title': _ms(BATTLE_RESULTS.COMMON_FITTING_PURCHASE),
'description': text_styles.main(item.userName),
'fittingType': item.itemTypeName,
'lvlIcon': getLevelIconPath(item.level),
'price': getItemPricesVO(ItemPrice(price=price, defPrice=price)),
'linkEvent': PROGRESS_ACTION.PURCHASE_UNLOCK_TYPE,
'linkId': unlockProps.parentID}
def getTradeInPrice(self, veh):
price = veh.buyPrices.itemPrice.price
defPrice = veh.buyPrices.itemPrice.defPrice
if self.validatePossibleVehicleToBuy(veh):
if self._vehicleToSellInfo.conversionRule.freeExchange:
price = MONEY_ZERO_GOLD
else:
price = max(MONEY_ZERO_GOLD, defPrice - self.getSelectedVehicleToSell().tradeOffPrice)
return ItemPrice(price, defPrice)
def _initialize(self, *args, **kwargs):
super(BuyVehicleView, self)._initialize()
self._blur = CachedBlur(enabled=True)
self.__addListeners()
isElite = self.__vehicle.isElite
vehType = self.__vehicle.type.replace('-', '_')
isRestore = self.__vehicle.isRestoreAvailable()
if self.__showOnlyCongrats:
self.viewModel.setIsContentHidden(True)
with self.viewModel.transaction() as vm:
vm.setIsRestore(isRestore)
vm.setBgSource(
R.images.gui.maps.icons.store.shop_2_background_arsenal())
vm.setTankType('{}_elite'.format(vehType) if isElite else vehType)
vehicleTooltip = i18n.makeString(
getTypeUserName(self.__vehicle.type, isElite))
noCrewLabelPath = R.strings.store.buyVehicleWindow.checkBox
vm.setVehicleNameTooltip(vehicleTooltip)
vm.setNation(nations.NAMES[self.__vehicle.nationID])
vm.setNoCrewCheckboxLabel(noCrewLabelPath.restore.withoutCrew(
) if isRestore else noCrewLabelPath.buy.withoutCrew())
vm.setTankLvl(int2roman(self.__vehicle.level))
vm.setTankName(self.__vehicle.shortUserName)
vm.setCountCrew(len(self.__vehicle.crew))
vm.setBuyVehicleIntCD(self.__vehicle.intCD)
vm.setIsElite(isElite)
if self.__vehicle.hasCrew:
vm.setWithoutCommanderAltText(
R.strings.store.buyVehicleWindow.crewInVehicle())
equipmentBlock = vm.equipmentBlock
equipmentBlock.setIsRentVisible(self.__isRentVisible)
equipmentBlock.setTradeInIsEnabled(self.__isTradeIn())
emtySlotAvailable = self.__itemsCache.items.inventory.getFreeSlots(
self.__stats.vehicleSlots) > 0
equipmentBlock.setEmtySlotAvailable(emtySlotAvailable)
equipmentBlock.setIsRestore(isRestore)
if self.__vehicle.hasRentPackages and (
not isRestore
or self.__actionType == VehicleBuyActionTypes.RENT
) and self.__actionType != VehicleBuyActionTypes.BUY:
self.__selectedRentIdx = 0
self.__selectedRentID = self.__vehicle.rentPackages[
self.__selectedRentIdx]['rentID']
self.__updateCommanderCards()
self.__updateSlotPrice()
self.__updateAmmoPrice()
self.__updateTradeInInfo()
self.__updateRentInfo()
self.__updateBuyBtnLabel()
totalPriceArray = equipmentBlock.totalPrice.getItems()
self.__addVMsInActionPriceList(
totalPriceArray,
ItemPrice(price=Money(credits=0, gold=0),
defPrice=Money(credits=0, gold=0)))
self.__updateTotalPrice()
def getPersonalTradeInPrice(self, veh):
price = veh.buyPrices.itemPrice.price
defPrice = veh.buyPrices.itemPrice.defPrice
if veh.canPersonalTradeInBuy and self.__activeTradeInSaleCD != UNDEFINED_ITEM_CD:
isFreeExchange, salePrice = self.__getSalePrice(veh)
if isFreeExchange:
price = MONEY_ZERO_GOLD
else:
price = defPrice - salePrice
if price.gold < 0:
price = MONEY_ZERO_GOLD
return ItemPrice(price, defPrice)
def __updateTankPrice(self):
if self.__isRentVisible:
if self.__selectedRentIdx == self.__RENT_NOT_SELECTED_IDX:
self.viewModel.setPriceDescription(
R.strings.store.buyVehicleWindow.priceDescription.restore)
defaultPrice = self.__vehicle.restorePrice
self.__updateTankPriceModel(
ItemPrice(self.__vehicle.restorePrice, defaultPrice))
elif self.__selectedRentIdx == self.__RENT_UNLIM_IDX:
self.viewModel.setPriceDescription(
R.strings.store.buyVehicleWindow.priceDescription.full)
self.__updateTankPriceModel(self.__vehicle.buyPrices.itemPrice)
else:
rentPackage = self.__vehicle.rentPackages[
self.__selectedRentIdx]
self.viewModel.setPriceDescription(
R.strings.store.buyVehicleWindow.priceDescription.rent)
self.__updateTankPriceModel(
ItemPrice(rentPackage['rentPrice'],
rentPackage['defaultRentPrice']))
elif self.__tradeOffVehicle is not None:
vehItemPrice = self.__vehicle.buyPrices.itemPrice
tradeOffPrice = vehItemPrice.price - self.__tradeOffVehicle.tradeOffPrice
tradeOffDefPrice = vehItemPrice.defPrice - self.__tradeOffVehicle.tradeOffPrice
self.__updateTankPriceModel(
ItemPrice(tradeOffPrice, tradeOffDefPrice))
self.viewModel.setPriceDescription(
R.strings.store.buyVehicleWindow.priceDescription.tradeIn)
elif self.__vehicle.isRestoreAvailable():
self.viewModel.setPriceDescription(
R.strings.store.buyVehicleWindow.priceDescription.restore)
defaultPrice = self.__vehicle.restorePrice
self.__updateTankPriceModel(
ItemPrice(self.__vehicle.restorePrice, defaultPrice))
else:
self.__updateTankPriceModel(self.__vehicle.buyPrices.itemPrice)
self.viewModel.setPriceDescription(
R.strings.store.buyVehicleWindow.priceDescription.full)
return
def getUpgradePrice(self, proxy=None):
if self.isUpgradable and proxy is not None:
price = proxy.shop.getOperationPrices().get(
ITEM_OPERATION.UPGRADE, {}).get(
(self.intCD,
self.descriptor.upgradeInfo.upgradedCompDescr), None)
defaultPrice = proxy.shop.defaults.getOperationPrices().get(
ITEM_OPERATION.UPGRADE, {}).get(
(self.intCD,
self.descriptor.upgradeInfo.upgradedCompDescr), None)
return ItemPrice(price=Money(**price),
defPrice=Money(**defaultPrice))
else:
return ITEM_PRICE_EMPTY
def _buildVehicle(self, item):
vo = super(_RestoreVehiclesDataProvider, self)._buildVehicle(item)
restoreCreditsPrice = item.restorePrice.credits
restorePrice = ItemPrice(item.restorePrice, item.restorePrice)
enoughCredits, _ = enoughCreditsForRestore(restoreCreditsPrice, self._itemsCache)
restoreAvailable, timerText, description, timerIcon = getVehicleRestoreInfo(item)
vo.update({'price': getItemPricesVO(restorePrice)[0],
'isMoneyEnough': enoughCredits,
'enabled': enoughCredits and restoreAvailable,
'description': description,
'timerText': timerText,
'timerIcon': timerIcon,
'contextMenuId': CONTEXT_MENU_HANDLER_TYPE.STORAGE_VEHICLES_RESTORE_ITEM})
return vo
def __setRepairPrice(self):
vehicle = g_currentVehicle.item
if isIncorrectVehicle(vehicle):
return
items = self.viewModel.repairPrice.getItems()
items.clear()
repairCost = vehicle.repairCost
itemPrice = ItemPrice(price=Money(credits=repairCost),
defPrice=Money(credits=repairCost))
actionPriceModels = getItemPricesViewModel(
self.__itemsCache.items.stats.money, itemPrice)[0]
for model in actionPriceModels:
items.addViewModel(model)
items.invalidate()
def _buildVehicle(self, item):
vo = super(_RestoreVehiclesDataProvider, self)._buildVehicle(item)
restoreCreditsPrice = item.restorePrice.credits
restorePrice = ItemPrice(item.restorePrice, item.restorePrice)
enoughCredits, _ = _enoughCreditsForRestore(restoreCreditsPrice,
self._itemsCache)
restoreAvailable, timerText, description, timerIcon = _getVehicleRestoreInfo(
item)
vo.update({
'price': getItemPricesVO(restorePrice)[0],
'isMoneyEnough': enoughCredits,
'enabled': enoughCredits and restoreAvailable,
'description': description,
'timerText': timerText,
'timerIcon': timerIcon
})
return vo
def __updateRentPrice(self):
vehicle = g_currentVehicle.item
if isIncorrectVehicle(vehicle):
return
else:
items = self.viewModel.rentPrice.getItems()
items.clear()
price = self.__rentVehiclesController.getRentPrice()
itemPrice = ItemPrice(price=price, defPrice=price)
actionPriceModels = getItemPricesViewModel(
self.__itemsCache.items.stats.getDynamicMoney(), itemPrice)[0]
isEnoughMoney = self.__rentVehiclesController.isEnoughMoneyToPurchase(
)
if actionPriceModels is not None:
for model in actionPriceModels:
items.addViewModel(model)
items.invalidate()
self.viewModel.setIsEnoughMoney(isEnoughMoney)
return
def __setBuyingPanelData(self, *_):
purchaseItems = self.getPurchaseItems()
cartInfo = getTotalPurchaseInfo(purchaseItems)
totalPriceVO = getItemPricesVO(cartInfo.totalPrice)
cleanSettings = self._cleanSettings(self._currentSettings, checkSeasons=False)
keys = []
if cartInfo.numTotal:
keys.append('install')
if cartInfo.totalPrice != ITEM_PRICE_EMPTY:
self.as_showBuyingPanelS()
else:
self.as_hideBuyingPanelS()
if any(cleanSettings.itervalues()) or not keys:
keys.append('apply')
label = g_config.i18n['UI_flash_commit_' + '_and_'.join(keys)]
isApplyEnabled = bool(cartInfo.numTotal) or any(cleanSettings.itervalues())
shortage = self.itemsCache.items.stats.money.getShortage(cartInfo.totalPrice.price)
self.as_setBottomPanelHeaderS({'buyBtnEnabled': isApplyEnabled,
'buyBtnLabel': label,
'enoughMoney': getItemPricesVO(ItemPrice(shortage, shortage))[0],
'pricePanel': totalPriceVO[0]})