672 lines
20 KiB
Lua
672 lines
20 KiB
Lua
|
-- ------------------------------------------------------------------------------ --
|
||
|
|
-- TradeSkillMaster --
|
||
|
|
-- https://tradeskillmaster.com --
|
||
|
|
-- All Rights Reserved - Detailed license information included with addon. --
|
||
|
|
-- ------------------------------------------------------------------------------ --
|
||
|
|
|
||
|
|
local _, TSM = ...
|
||
|
|
local ResultRow = TSM.Init("Service.AuctionScanClasses.ResultRow")
|
||
|
|
local ItemString = TSM.Include("Util.ItemString")
|
||
|
|
local ObjectPool = TSM.Include("Util.ObjectPool")
|
||
|
|
local TempTable = TSM.Include("Util.TempTable")
|
||
|
|
local Table = TSM.Include("Util.Table")
|
||
|
|
local ItemInfo = TSM.Include("Service.ItemInfo")
|
||
|
|
local LibTSMClass = TSM.Include("LibTSMClass")
|
||
|
|
local Util = TSM.Include("Service.AuctionScanClasses.Util")
|
||
|
|
local AuctionHouseWrapper = TSM.Include("Service.AuctionHouseWrapper")
|
||
|
|
local ResultSubRow = TSM.Include("Service.AuctionScanClasses.ResultSubRow")
|
||
|
|
local ResultRowWrapper = LibTSMClass.DefineClass("ResultRowWrapper")
|
||
|
|
local private = {
|
||
|
|
objectPool = ObjectPool.New("AUCTION_SCAN_RESULT_ROW", ResultRowWrapper),
|
||
|
|
}
|
||
|
|
local SUB_ROW_SEARCH_INDEX_MULTIPLIER = 1000000
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
-- ============================================================================
|
||
|
|
-- Module Functions
|
||
|
|
-- ============================================================================
|
||
|
|
|
||
|
|
function ResultRow.Get(query, itemKey, minPrice, totalQuantity)
|
||
|
|
local row = private.objectPool:Get()
|
||
|
|
row:_Acquire(query, itemKey, minPrice, totalQuantity)
|
||
|
|
return row
|
||
|
|
end
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
-- ============================================================================
|
||
|
|
-- ResultRowWrapper - Meta Class Methods
|
||
|
|
-- ============================================================================
|
||
|
|
|
||
|
|
function ResultRowWrapper.__init(self)
|
||
|
|
self._query = nil
|
||
|
|
self._items = {}
|
||
|
|
self._baseItemString = nil
|
||
|
|
self._canHaveNonBaseItemString = nil
|
||
|
|
self._minPrice = nil
|
||
|
|
self._hasItemInfo = nil
|
||
|
|
self._isCommodity = nil
|
||
|
|
self._notFiltered = false
|
||
|
|
self._searchIndex = nil
|
||
|
|
self._subRows = {}
|
||
|
|
self._minBrowseId = nil
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper._Acquire(self, query, item, minPrice, totalQuantity)
|
||
|
|
self._query = query
|
||
|
|
if TSM.IsWowClassic() then
|
||
|
|
assert(not minPrice and not totalQuantity)
|
||
|
|
tinsert(self._items, item)
|
||
|
|
self._baseItemString = ItemString.GetBase(item)
|
||
|
|
else
|
||
|
|
item._minPrice = minPrice
|
||
|
|
item._totalQuantity = totalQuantity
|
||
|
|
tinsert(self._items, item)
|
||
|
|
self._baseItemString = ItemString.GetBaseFromItemKey(item)
|
||
|
|
end
|
||
|
|
self._canHaveNonBaseItemString = nil
|
||
|
|
self._minPrice = nil
|
||
|
|
end
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
-- ============================================================================
|
||
|
|
-- ResultRowWrapper - Public Class Methods
|
||
|
|
-- ============================================================================
|
||
|
|
|
||
|
|
function ResultRowWrapper.Merge(self, item, minPrice, totalQuantity)
|
||
|
|
-- check if we already have this item
|
||
|
|
for i = 1, #self._items do
|
||
|
|
if item == self._items[i] then
|
||
|
|
return
|
||
|
|
end
|
||
|
|
if type(item) == "table" then
|
||
|
|
local isEqual = true
|
||
|
|
for k in pairs(item) do
|
||
|
|
if item[k] ~= self._items[i][k] then
|
||
|
|
isEqual = false
|
||
|
|
break
|
||
|
|
end
|
||
|
|
end
|
||
|
|
if isEqual then
|
||
|
|
return
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
self._hasItemInfo = nil
|
||
|
|
if TSM.IsWowClassic() then
|
||
|
|
assert(not minPrice and not totalQuantity)
|
||
|
|
assert(self._baseItemString == ItemString.GetBase(item))
|
||
|
|
tinsert(self._items, item)
|
||
|
|
self._notFiltered = false
|
||
|
|
else
|
||
|
|
assert(self._baseItemString == ItemString.GetBaseFromItemKey(item))
|
||
|
|
item._minPrice = minPrice
|
||
|
|
item._totalQuantity = totalQuantity
|
||
|
|
tinsert(self._items, item)
|
||
|
|
self._notFiltered = false
|
||
|
|
end
|
||
|
|
self._canHaveNonBaseItemString = nil
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.Release(self)
|
||
|
|
wipe(self._items)
|
||
|
|
self._baseItemString = nil
|
||
|
|
self._canHaveNonBaseItemString = nil
|
||
|
|
self._minPrice = nil
|
||
|
|
self._hasItemInfo = nil
|
||
|
|
self._isCommodity = nil
|
||
|
|
self._notFiltered = false
|
||
|
|
self._searchIndex = nil
|
||
|
|
self._minBrowseId = nil
|
||
|
|
for _, subRow in pairs(self._subRows) do
|
||
|
|
subRow:Release()
|
||
|
|
end
|
||
|
|
wipe(self._subRows)
|
||
|
|
private.objectPool:Recycle(self)
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.IsSubRow(self)
|
||
|
|
return false
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.PopulateBrowseData(self)
|
||
|
|
assert(self._baseItemString)
|
||
|
|
if self._hasItemInfo then
|
||
|
|
-- already have our item info
|
||
|
|
return true
|
||
|
|
elseif not Util.HasItemInfo(self._baseItemString) then
|
||
|
|
-- don't have item info yet
|
||
|
|
return false
|
||
|
|
end
|
||
|
|
|
||
|
|
if not TSM.IsWowClassic() then
|
||
|
|
-- cache the commodity status since it's referenced a ton
|
||
|
|
if self._isCommodity == nil then
|
||
|
|
self._isCommodity = ItemInfo.IsCommodity(self._baseItemString)
|
||
|
|
assert(self._isCommodity ~= nil)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
-- check if we have info for all the items and try to fetch it if not
|
||
|
|
local missingInfo = false
|
||
|
|
for _, item in ipairs(self._items) do
|
||
|
|
if TSM.IsWowClassic() then
|
||
|
|
if not Util.HasItemInfo(ItemString.Get(item)) then
|
||
|
|
missingInfo = true
|
||
|
|
end
|
||
|
|
else
|
||
|
|
if not item._itemKeyInfo then
|
||
|
|
item._itemKeyInfo = C_AuctionHouse.GetItemKeyInfo(item, true)
|
||
|
|
if not item._itemKeyInfo then
|
||
|
|
missingInfo = true
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
if missingInfo then
|
||
|
|
return false
|
||
|
|
end
|
||
|
|
|
||
|
|
self._hasItemInfo = true
|
||
|
|
return true
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.IsFiltered(self, query)
|
||
|
|
assert(#self._items > 0)
|
||
|
|
if self._notFiltered then
|
||
|
|
return false
|
||
|
|
end
|
||
|
|
|
||
|
|
-- check if the whole row is filtered
|
||
|
|
if query:_IsFiltered(self, false) then
|
||
|
|
return true
|
||
|
|
end
|
||
|
|
|
||
|
|
-- filter our items
|
||
|
|
for i = #self._items, 1, -1 do
|
||
|
|
if query:_IsFiltered(self, false, self._items[i]) then
|
||
|
|
tremove(self._items, i)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
self._canHaveNonBaseItemString = nil
|
||
|
|
self._minPrice = nil
|
||
|
|
if #self._items == 0 then
|
||
|
|
-- no more items, so the entire row is filtered
|
||
|
|
return true
|
||
|
|
end
|
||
|
|
|
||
|
|
-- not filtered (cache this result)
|
||
|
|
self._notFiltered = true
|
||
|
|
return false
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.SearchReset(self)
|
||
|
|
assert(not TSM.IsWowClassic())
|
||
|
|
assert(#self._items > 0)
|
||
|
|
self._searchIndex = 1
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.SearchNext(self)
|
||
|
|
assert(not TSM.IsWowClassic())
|
||
|
|
assert(self._searchIndex)
|
||
|
|
if self._searchIndex == #self._items then
|
||
|
|
self._searchIndex = nil
|
||
|
|
return false
|
||
|
|
end
|
||
|
|
self._searchIndex = self._searchIndex + 1
|
||
|
|
return true
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.SearchIsReady(self)
|
||
|
|
assert(not TSM.IsWowClassic())
|
||
|
|
assert(self._searchIndex)
|
||
|
|
-- the client needs to have the item key info cached before we can run the search
|
||
|
|
return C_AuctionHouse.GetItemKeyInfo(self._items[self._searchIndex], true) and true or false
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.SearchSend(self)
|
||
|
|
assert(not TSM.IsWowClassic())
|
||
|
|
assert(self._searchIndex)
|
||
|
|
local itemKey = self._items[self._searchIndex]
|
||
|
|
-- send a sell query if we don't have browse results for the itemKey
|
||
|
|
-- for some reason sell queries don't work for commodities or pets
|
||
|
|
local isSellQuery = not self._isCommodity and not ItemString.IsPet(self._baseItemString) and not itemKey._totalQuantity
|
||
|
|
return AuctionHouseWrapper.SendSearchQuery(itemKey, isSellQuery)
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.HasCachedSearchData(self)
|
||
|
|
local itemKey = self._items[self._searchIndex]
|
||
|
|
if self._isCommodity then
|
||
|
|
return C_AuctionHouse.HasFullCommoditySearchResults(itemKey.itemID)
|
||
|
|
else
|
||
|
|
return C_AuctionHouse.HasFullItemSearchResults(itemKey)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.SearchCheckStatus(self)
|
||
|
|
assert(not TSM.IsWowClassic())
|
||
|
|
assert(self._searchIndex)
|
||
|
|
local itemKey = self._items[self._searchIndex]
|
||
|
|
|
||
|
|
-- check if we have the full results
|
||
|
|
local hasFullResults = nil
|
||
|
|
if self._isCommodity then
|
||
|
|
hasFullResults = C_AuctionHouse.HasFullCommoditySearchResults(itemKey.itemID)
|
||
|
|
else
|
||
|
|
hasFullResults = C_AuctionHouse.HasFullItemSearchResults(itemKey)
|
||
|
|
end
|
||
|
|
if hasFullResults then
|
||
|
|
return true
|
||
|
|
end
|
||
|
|
|
||
|
|
-- request more results
|
||
|
|
if self._isCommodity then
|
||
|
|
return false, AuctionHouseWrapper.RequestMoreCommoditySearchResults(itemKey.itemID)
|
||
|
|
else
|
||
|
|
return false, AuctionHouseWrapper.RequestMoreItemSearchResults(itemKey)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.PopulateSubRows(self, browseId, index, itemLink)
|
||
|
|
if TSM.IsWowClassic() then
|
||
|
|
-- remove any prior results with a different browseId
|
||
|
|
assert(index and not self._searchIndex)
|
||
|
|
local subRow = ResultSubRow.Get(self)
|
||
|
|
subRow:_SetRawData(index, browseId, itemLink)
|
||
|
|
local _, hashNoSeller = subRow:GetHashes()
|
||
|
|
if self._minBrowseId and self._minBrowseId ~= browseId then
|
||
|
|
-- check if this subRow already exists with a prior browseId
|
||
|
|
for i, existingSubRow in ipairs(self._subRows) do
|
||
|
|
local _, existingHashNoSeller = existingSubRow:GetHashes()
|
||
|
|
local _, _, existingBrowseId = existingSubRow:GetListingInfo()
|
||
|
|
if hashNoSeller == existingHashNoSeller and browseId ~= existingBrowseId then
|
||
|
|
-- replace the existing subRow
|
||
|
|
existingSubRow:Release()
|
||
|
|
self._subRows[i] = subRow
|
||
|
|
return
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
tinsert(self._subRows, subRow)
|
||
|
|
else
|
||
|
|
assert(self._searchIndex and not index)
|
||
|
|
local subRowOffset = self._searchIndex * SUB_ROW_SEARCH_INDEX_MULTIPLIER
|
||
|
|
local itemKey = self._items[self._searchIndex]
|
||
|
|
local numAuctions = nil
|
||
|
|
if self:IsCommodity() then
|
||
|
|
numAuctions = C_AuctionHouse.GetNumCommoditySearchResults(itemKey.itemID)
|
||
|
|
else
|
||
|
|
numAuctions = C_AuctionHouse.GetNumItemSearchResults(itemKey)
|
||
|
|
end
|
||
|
|
if itemKey._numAuctions and numAuctions ~= itemKey._numAuctions then
|
||
|
|
-- the results changed so clear out our existing data
|
||
|
|
for i = itemKey._numAuctions, 1, -1 do
|
||
|
|
if i > numAuctions then
|
||
|
|
self._subRows[subRowOffset + i]:Release()
|
||
|
|
self._subRows[subRowOffset + i] = nil
|
||
|
|
else
|
||
|
|
self._subRows[subRowOffset + i]:_SetRawData(nil)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
itemKey._numAuctions = numAuctions
|
||
|
|
for i = 1, numAuctions do
|
||
|
|
self._subRows[subRowOffset + i] = self._subRows[subRowOffset + i] or ResultSubRow.Get(self)
|
||
|
|
local subRow = self._subRows[subRowOffset + i]
|
||
|
|
if not subRow:HasRawData() or not subRow:HasOwners() then
|
||
|
|
local result = nil
|
||
|
|
if self:IsCommodity() then
|
||
|
|
result = C_AuctionHouse.GetCommoditySearchResultInfo(itemKey.itemID, i)
|
||
|
|
else
|
||
|
|
result = C_AuctionHouse.GetItemSearchResultInfo(itemKey, i)
|
||
|
|
end
|
||
|
|
subRow:_SetRawData(result, browseId)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
self._minBrowseId = min(self._minBrowseId or math.huge, browseId)
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.FilterSubRows(self, query)
|
||
|
|
local subRowOffset = TSM.IsWowClassic() and 0 or (self._searchIndex * SUB_ROW_SEARCH_INDEX_MULTIPLIER)
|
||
|
|
if TSM.IsWowClassic() then
|
||
|
|
for i = #self._subRows, 1, -1 do
|
||
|
|
if query:_IsFiltered(self._subRows[i], true) then
|
||
|
|
self:_RemoveSubRowByIndex(i)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
else
|
||
|
|
local itemKey = self._items[self._searchIndex]
|
||
|
|
for j = itemKey._numAuctions, 1, -1 do
|
||
|
|
local subRow = self._subRows[subRowOffset + j]
|
||
|
|
if query:_IsFiltered(subRow, true) then
|
||
|
|
self:_RemoveSubRowByIndex(j)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
-- merge subRows with identical hashes
|
||
|
|
local numSubRows = nil
|
||
|
|
local hashIndexLookup = TempTable.Acquire()
|
||
|
|
local index = 1
|
||
|
|
while true do
|
||
|
|
numSubRows = TSM.IsWowClassic() and #self._subRows or self._items[self._searchIndex]._numAuctions
|
||
|
|
if index > numSubRows then
|
||
|
|
break
|
||
|
|
end
|
||
|
|
local subRow = self._subRows[subRowOffset + index]
|
||
|
|
local hash = subRow:GetHashes()
|
||
|
|
local prevIndex = hashIndexLookup[hash]
|
||
|
|
if prevIndex then
|
||
|
|
-- there was a previous subRow with the same hash
|
||
|
|
self._subRows[subRowOffset + prevIndex]:Merge(subRow)
|
||
|
|
-- remove this subRow
|
||
|
|
self:_RemoveSubRowByIndex(index)
|
||
|
|
else
|
||
|
|
hashIndexLookup[hash] = index
|
||
|
|
index = index + 1
|
||
|
|
end
|
||
|
|
end
|
||
|
|
TempTable.Release(hashIndexLookup)
|
||
|
|
return numSubRows == 0
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.GetNumSubRows(self)
|
||
|
|
if TSM.IsWowClassic() then
|
||
|
|
return #self._subRows
|
||
|
|
else
|
||
|
|
local result = 0
|
||
|
|
for _, itemKey in ipairs(self._items) do
|
||
|
|
result = result + (itemKey._numAuctions or 0)
|
||
|
|
end
|
||
|
|
return result
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.SubRowIterator(self, searchOnly)
|
||
|
|
if TSM.IsWowClassic() then
|
||
|
|
return ipairs(self._subRows)
|
||
|
|
else
|
||
|
|
if searchOnly then
|
||
|
|
local result = TempTable.Acquire()
|
||
|
|
assert(self._searchIndex)
|
||
|
|
for i = 1, self._items[self._searchIndex]._numAuctions do
|
||
|
|
local subRow = self._subRows[self._searchIndex * SUB_ROW_SEARCH_INDEX_MULTIPLIER + i]
|
||
|
|
assert(subRow)
|
||
|
|
tinsert(result, subRow)
|
||
|
|
end
|
||
|
|
return TempTable.Iterator(result)
|
||
|
|
else
|
||
|
|
return private.SubRowIteratorHelper, self, SUB_ROW_SEARCH_INDEX_MULTIPLIER
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.IsCommodity(self)
|
||
|
|
assert(self._isCommodity ~= nil)
|
||
|
|
return self._isCommodity
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.HasItemInfo(self)
|
||
|
|
return self._hasItemInfo
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.GetBaseItemString(self)
|
||
|
|
return self._baseItemString
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.GetItemString(self)
|
||
|
|
if TSM.IsWowClassic() or not self._hasItemInfo or self._canHaveNonBaseItemString then
|
||
|
|
return nil
|
||
|
|
end
|
||
|
|
if self._canHaveNonBaseItemString == nil then
|
||
|
|
for _, itemKey in ipairs(self._items) do
|
||
|
|
if ItemInfo.CanHaveVariations(self._baseItemString) or itemKey.battlePetSpeciesID ~= 0 or itemKey.itemSuffix ~= 0 or itemKey.itemLevel ~= 0 then
|
||
|
|
-- this item can have variations, so we don't know its itemString
|
||
|
|
self._canHaveNonBaseItemString = true
|
||
|
|
return nil
|
||
|
|
end
|
||
|
|
end
|
||
|
|
self._canHaveNonBaseItemString = false
|
||
|
|
end
|
||
|
|
return self._baseItemString
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.GetItemInfo(self, itemKey)
|
||
|
|
if TSM.IsWowClassic() or not self._hasItemInfo then
|
||
|
|
return nil, nil, nil, nil
|
||
|
|
end
|
||
|
|
itemKey = itemKey or (#self._items == 1 and self._items[1] or nil)
|
||
|
|
assert(not itemKey or itemKey._itemKeyInfo)
|
||
|
|
local baseItemString = self:GetBaseItemString()
|
||
|
|
local itemString = self:GetItemString()
|
||
|
|
local itemName, quality, itemLevel, maxItemLevel = nil, nil, nil, nil
|
||
|
|
if itemString then
|
||
|
|
-- this item can't have variations, so we can know the name / level / quality
|
||
|
|
itemName = ItemInfo.GetName(baseItemString)
|
||
|
|
itemLevel = ItemInfo.GetItemLevel(baseItemString)
|
||
|
|
quality = ItemInfo.GetQuality(baseItemString)
|
||
|
|
assert(itemName and itemLevel and quality)
|
||
|
|
else
|
||
|
|
if itemKey and not itemKey._totalQuantity then
|
||
|
|
-- if we didn't do a browse, then don't use this itemKey
|
||
|
|
itemKey = nil
|
||
|
|
end
|
||
|
|
if itemKey then
|
||
|
|
-- grab the name from the itemKeyInfo
|
||
|
|
itemName = itemKey._itemKeyInfo.itemName
|
||
|
|
assert(itemName)
|
||
|
|
end
|
||
|
|
local hasSingleAuction = itemKey and itemKey._totalQuantity == 1
|
||
|
|
if hasSingleAuction then
|
||
|
|
-- grab the quality from the itemKeyInfo since there's only one listing
|
||
|
|
quality = itemKey._itemKeyInfo.quality
|
||
|
|
assert(quality)
|
||
|
|
end
|
||
|
|
if not ItemString.IsPet(self._baseItemString) then
|
||
|
|
-- for non-pets, we can maybe grab the itemLevel from the itemKey
|
||
|
|
if itemKey then
|
||
|
|
itemLevel = itemKey.itemLevel ~= 0 and itemKey.itemLevel or nil
|
||
|
|
else
|
||
|
|
-- only use the itemLevel from the itemKeys if they are all the same
|
||
|
|
local itemKeyItemLevel = self._items[1].itemLevel
|
||
|
|
for i = 2, #self._items do
|
||
|
|
if self._items[i].itemLevel ~= itemKeyItemLevel then
|
||
|
|
itemKeyItemLevel = nil
|
||
|
|
break
|
||
|
|
end
|
||
|
|
end
|
||
|
|
itemLevel = (itemKeyItemLevel or 0) ~= 0 and itemKeyItemLevel or nil
|
||
|
|
end
|
||
|
|
elseif itemKey and itemKey._itemKeyInfo.battlePetLink then
|
||
|
|
if hasSingleAuction then
|
||
|
|
-- grab the itemLevel from the link since there's only one listing
|
||
|
|
itemLevel = ItemInfo.GetItemLevel(itemKey._itemKeyInfo.battlePetLink)
|
||
|
|
assert(itemLevel)
|
||
|
|
else
|
||
|
|
-- grab the maxItemLevel from the link
|
||
|
|
maxItemLevel = ItemInfo.GetItemLevel(itemKey._itemKeyInfo.battlePetLink)
|
||
|
|
assert(maxItemLevel)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
return itemName, quality, itemLevel, maxItemLevel
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.GetBuyouts(self, resultItemKey)
|
||
|
|
if TSM.IsWowClassic() then
|
||
|
|
return nil, nil, nil
|
||
|
|
end
|
||
|
|
assert(#self._items > 0)
|
||
|
|
if resultItemKey then
|
||
|
|
return nil, nil, resultItemKey._minPrice
|
||
|
|
else
|
||
|
|
if self._minPrice == nil then
|
||
|
|
for _, itemKey in ipairs(self._items) do
|
||
|
|
if not itemKey._minPrice then
|
||
|
|
self._minPrice = -1
|
||
|
|
return nil, nil, nil
|
||
|
|
end
|
||
|
|
self._minPrice = min(self._minPrice or math.huge, itemKey._minPrice)
|
||
|
|
end
|
||
|
|
elseif self._minPrice == -1 then
|
||
|
|
return nil, nil, nil
|
||
|
|
end
|
||
|
|
return nil, nil, self._minPrice
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.GetQuantities(self)
|
||
|
|
local totalQuantity = 0
|
||
|
|
if TSM.IsWowClassic() then
|
||
|
|
for _, subRow in ipairs(self._subRows) do
|
||
|
|
local quantity, numAuctions = subRow:GetQuantities()
|
||
|
|
totalQuantity = totalQuantity + quantity * numAuctions
|
||
|
|
end
|
||
|
|
else
|
||
|
|
for _, itemKey in ipairs(self._items) do
|
||
|
|
if not itemKey._totalQuantity then
|
||
|
|
return
|
||
|
|
end
|
||
|
|
totalQuantity = totalQuantity + itemKey._totalQuantity
|
||
|
|
end
|
||
|
|
end
|
||
|
|
return totalQuantity, 1
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.GetMaxQuantities(self)
|
||
|
|
assert(self:IsCommodity())
|
||
|
|
local totalQuantity = 0
|
||
|
|
for _, subRow in self:SubRowIterator() do
|
||
|
|
local _, numOwnerItems = subRow:GetOwnerInfo()
|
||
|
|
local quantityAvailable = subRow:GetQuantities() - numOwnerItems
|
||
|
|
totalQuantity = totalQuantity + quantityAvailable
|
||
|
|
end
|
||
|
|
return totalQuantity
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.RemoveSubRow(self, subRow)
|
||
|
|
local index = Table.KeyByValue(self._subRows, subRow)
|
||
|
|
if TSM.IsWowClassic() then
|
||
|
|
self:_RemoveSubRowByIndex(index)
|
||
|
|
else
|
||
|
|
local searchIndex = floor(index / SUB_ROW_SEARCH_INDEX_MULTIPLIER)
|
||
|
|
index = index % SUB_ROW_SEARCH_INDEX_MULTIPLIER
|
||
|
|
assert(self._subRows[searchIndex * SUB_ROW_SEARCH_INDEX_MULTIPLIER + index] == subRow)
|
||
|
|
local prevSearchIndex = self._searchIndex
|
||
|
|
self._searchIndex = searchIndex
|
||
|
|
self:_RemoveSubRowByIndex(index)
|
||
|
|
self._searchIndex = prevSearchIndex
|
||
|
|
end
|
||
|
|
self._query:_OnSubRowRemoved(self)
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.WipeSearchResults(self)
|
||
|
|
wipe(self._subRows)
|
||
|
|
if not TSM.IsWowClassic() then
|
||
|
|
for _, itemKey in ipairs(self._items) do
|
||
|
|
itemKey._numAuctions = nil
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.GetQuery(self)
|
||
|
|
return self._query
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.DecrementQuantity(self, amount)
|
||
|
|
assert(self:IsCommodity() and not TSM.IsWowClassic() and #self._items == 1)
|
||
|
|
local index = 1
|
||
|
|
while amount > 0 do
|
||
|
|
local subRow = self._subRows[index + SUB_ROW_SEARCH_INDEX_MULTIPLIER]
|
||
|
|
assert(subRow)
|
||
|
|
local _, numOwnerItems = subRow:GetOwnerInfo()
|
||
|
|
local quantityAvailable = subRow:GetQuantities() - numOwnerItems
|
||
|
|
if quantityAvailable > 0 then
|
||
|
|
local usedQuantity = min(quantityAvailable, amount)
|
||
|
|
local prevItemBuyout = floor(subRow._buyout / subRow._quantity)
|
||
|
|
amount = amount - usedQuantity
|
||
|
|
subRow._quantity = subRow._quantity - usedQuantity
|
||
|
|
subRow._buyout = prevItemBuyout * subRow._quantity
|
||
|
|
subRow._minBid = subRow._buyout
|
||
|
|
if numOwnerItems == 0 and subRow._quantity == 0 then
|
||
|
|
self:RemoveSubRow(subRow)
|
||
|
|
else
|
||
|
|
index = index + 1
|
||
|
|
end
|
||
|
|
else
|
||
|
|
index = index + 1
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper.GetMinBrowseId(self)
|
||
|
|
return self._minBrowseId
|
||
|
|
end
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
-- ============================================================================
|
||
|
|
-- ResultRowWrapper - Private Class Methods
|
||
|
|
-- ============================================================================
|
||
|
|
|
||
|
|
function ResultRowWrapper._RemoveSubRowByIndex(self, index)
|
||
|
|
if TSM.IsWowClassic() then
|
||
|
|
self._subRows[index]:Release()
|
||
|
|
tremove(self._subRows, index)
|
||
|
|
else
|
||
|
|
local subRowOffset = self._searchIndex * SUB_ROW_SEARCH_INDEX_MULTIPLIER
|
||
|
|
local itemKey = self._items[self._searchIndex]
|
||
|
|
self._subRows[subRowOffset + index]:Release()
|
||
|
|
self._subRows[subRowOffset + index] = nil
|
||
|
|
-- shift the other subRows for this item down
|
||
|
|
for i = index, itemKey._numAuctions - 1 do
|
||
|
|
self._subRows[subRowOffset + i] = self._subRows[subRowOffset + i + 1]
|
||
|
|
end
|
||
|
|
self._subRows[subRowOffset + itemKey._numAuctions] = nil
|
||
|
|
itemKey._numAuctions = itemKey._numAuctions - 1
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
function ResultRowWrapper._GetSearchProgress(self)
|
||
|
|
assert(not TSM.IsWowClassic())
|
||
|
|
if #self._items == 0 then
|
||
|
|
return 0
|
||
|
|
end
|
||
|
|
local numSearched = 0
|
||
|
|
for _, itemKey in ipairs(self._items) do
|
||
|
|
if itemKey._numAuctions then
|
||
|
|
numSearched = numSearched + 1
|
||
|
|
end
|
||
|
|
end
|
||
|
|
return numSearched / #self._items
|
||
|
|
end
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
-- ============================================================================
|
||
|
|
-- Private Helper Functions
|
||
|
|
-- ============================================================================
|
||
|
|
|
||
|
|
function private.SubRowIteratorHelper(row, index)
|
||
|
|
local searchIndex = floor(index / SUB_ROW_SEARCH_INDEX_MULTIPLIER)
|
||
|
|
local subRowIndex = index % SUB_ROW_SEARCH_INDEX_MULTIPLIER
|
||
|
|
while true do
|
||
|
|
local itemKey = row._items[searchIndex]
|
||
|
|
if not itemKey then
|
||
|
|
return
|
||
|
|
end
|
||
|
|
|
||
|
|
if subRowIndex >= (itemKey._numAuctions or 0) then
|
||
|
|
searchIndex = searchIndex + 1
|
||
|
|
subRowIndex = 0
|
||
|
|
else
|
||
|
|
subRowIndex = subRowIndex + 1
|
||
|
|
index = searchIndex * SUB_ROW_SEARCH_INDEX_MULTIPLIER + subRowIndex
|
||
|
|
return index, row._subRows[index]
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|