You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
355 lines
12 KiB
355 lines
12 KiB
-- ------------------------------------------------------------------------------ -- |
|
-- TradeSkillMaster_Auctioning -- |
|
-- http://www.curse.com/addons/wow/tradeskillmaster_auctioning -- |
|
-- -- |
|
-- A TradeSkillMaster Addon (http://tradeskillmaster.com) -- |
|
-- All Rights Reserved* - Detailed license information included with addon. -- |
|
-- ------------------------------------------------------------------------------ -- |
|
|
|
local TSM = select(2, ...) |
|
local Util = TSM:NewModule("Util") |
|
local L = LibStub("AceLocale-3.0"):GetLocale("TradeSkillMaster_Auctioning") -- loads the localization table |
|
|
|
local currentBank = nil |
|
local bFrame = nil |
|
local buttonFrame = nil |
|
local groupTree = nil |
|
|
|
function Util:OnEnable() |
|
TSM:RegisterEvent("GUILDBANKFRAME_OPENED", function(event) |
|
currentBank = "guildbank" |
|
end) |
|
|
|
TSM:RegisterEvent("BANKFRAME_OPENED", function(event) |
|
currentBank = "bank" |
|
end) |
|
|
|
TSM:RegisterEvent("GUILDBANKFRAME_CLOSED", function(event, addon) |
|
currentBank = nil |
|
end) |
|
|
|
TSM:RegisterEvent("BANKFRAME_CLOSED", function(event) |
|
currentBank = nil |
|
end) |
|
end |
|
|
|
local function GetItemPrice(operationPrice, itemString) |
|
local func = TSMAPI:ParseCustomPrice(operationPrice) |
|
local price = func and func(itemString) |
|
return price ~= 0 and price or nil |
|
end |
|
|
|
function Util:GetItemPrices(operation, itemString, isResetScan) |
|
local prices = {} |
|
|
|
prices.cost = GetItemPrice("crafting", itemString) |
|
|
|
prices.undercut = GetItemPrice(operation.undercut, itemString) |
|
prices.minPrice = GetItemPrice(operation.minPrice, itemString) |
|
prices.maxPrice = GetItemPrice(operation.maxPrice, itemString) |
|
prices.normalPrice = GetItemPrice(operation.normalPrice, itemString) |
|
prices.cancelRepostThreshold = GetItemPrice(operation.cancelRepostThreshold, itemString) |
|
if isResetScan then |
|
prices.resetMaxCost = GetItemPrice(operation.resetMaxCost, itemString) |
|
prices.resetMinProfit = GetItemPrice(operation.resetMinProfit, itemString) |
|
prices.resetResolution = GetItemPrice(operation.resetResolution, itemString) |
|
prices.resetMaxItemCost = GetItemPrice(operation.resetMaxItemCost, itemString) |
|
end |
|
if TSM.db.global.roundNormalPrice and prices.normalPrice then |
|
prices.normalPrice = ceil(prices.normalPrice / COPPER_PER_GOLD) * COPPER_PER_GOLD |
|
end |
|
prices.resetPrice = operation.priceReset ~= "none" and operation.priceReset ~= "ignore" and prices[operation.priceReset] |
|
prices.aboveMax = operation.aboveMax ~= "none" and prices[operation.aboveMax] |
|
return prices |
|
end |
|
|
|
local function createButton(text, parent, func) |
|
local btn = TSMAPI.GUI:CreateButton(bFrame, 15, "Button") |
|
btn:SetText(text) |
|
btn:SetHeight(17) |
|
btn:SetWidth(230) |
|
return btn |
|
end |
|
|
|
function Util:createTab(parent) |
|
|
|
bFrame = CreateFrame("Frame", nil, parent) |
|
--TSMAPI.Design:SetFrameColor(bFrame) |
|
bFrame:Hide() |
|
|
|
--size-- |
|
bFrame:SetAllPoints() |
|
|
|
--GroupTree-- |
|
local tFrame = CreateFrame("Frame", nil, bFrame) |
|
tFrame:SetPoint("TOPLEFT", 0, -5) |
|
tFrame:SetPoint("TOPRIGHT", 0, -5) |
|
tFrame:SetPoint("BOTTOMLEFT", 0, 120) |
|
tFrame:SetPoint("BOTTOMRIGHT", 0, 120) |
|
|
|
groupTree = TSMAPI:CreateGroupTree(tFrame, "Auctioning", "Auctioning_Bank") |
|
groupTree:SetPoint("TOPLEFT", 5, -5) |
|
groupTree:SetPoint("BOTTOMRIGHT", -5, 5) |
|
|
|
--Buttons-- |
|
buttonFrame = CreateFrame("Frame", nil, bFrame) |
|
buttonFrame:SetPoint("TOPLEFT", 0, -330) |
|
buttonFrame:SetPoint("TOPRIGHT", 0, -330) |
|
buttonFrame:SetPoint("BOTTOMLEFT") |
|
buttonFrame:SetPoint("BOTTOMRIGHT") |
|
|
|
buttonFrame.btnToBank = createButton(L["Move Group To Bank"], buttonFrame, nil) |
|
buttonFrame.btnToBank:SetPoint("BOTTOM", buttonFrame, "BOTTOM", 0, 95) |
|
|
|
buttonFrame.btnNonGroup = createButton(L["Move Non Group Items to Bank"], buttonFrame, nil) |
|
buttonFrame.btnNonGroup:SetPoint("BOTTOM", buttonFrame, "BOTTOM", 0, 75) |
|
|
|
buttonFrame.btnToBags = createButton(L["Move Post Cap To Bags"], buttonFrame, nil) |
|
buttonFrame.btnToBags:SetPoint("BOTTOM", buttonFrame, "BOTTOM", 0, 45) |
|
|
|
buttonFrame.btnAHToBags = createButton(L["Move AH Shortfall To Bags"], buttonFrame, nil) |
|
buttonFrame.btnAHToBags:SetPoint("BOTTOM", buttonFrame, "BOTTOM", 0, 25) |
|
|
|
buttonFrame.btnAllToBags = createButton(L["Move Group To Bags"], buttonFrame, nil) |
|
buttonFrame.btnAllToBags:SetPoint("BOTTOM", buttonFrame, "BOTTOM", 0, 5) |
|
|
|
Util:updateButtons() |
|
|
|
return bFrame |
|
end |
|
|
|
function Util:updateButtons() |
|
------------------ |
|
-- Move to Bank -- |
|
------------------ |
|
buttonFrame.btnToBank:SetScript("OnClick", function(self) |
|
Util:groupTree(groupTree:GetSelectedGroupInfo(), "bags") |
|
end) |
|
|
|
----------------------------------- |
|
-- Move Non Group Items to Bank -- |
|
----------------------------------- |
|
buttonFrame.btnNonGroup:SetScript("OnClick", function(self) |
|
Util:nonGroupTree(groupTree:GetSelectedGroupInfo(), "bags") |
|
end) |
|
|
|
---------------------------- |
|
-- Move Post Cap to Bags -- |
|
---------------------------- |
|
buttonFrame.btnToBags:SetScript("OnClick", function(self) |
|
Util:groupTree(groupTree:GetSelectedGroupInfo(), currentBank) |
|
end) |
|
|
|
-------------------------------- |
|
-- Move AH Shortfall to Bags -- |
|
-------------------------------- |
|
buttonFrame.btnAHToBags:SetScript("OnClick", function(self) |
|
Util:groupTree(groupTree:GetSelectedGroupInfo(), currentBank, false, true) |
|
end) |
|
|
|
|
|
---------------------------- |
|
-- Move All to Bags -- |
|
---------------------------- |
|
buttonFrame.btnAllToBags:SetScript("OnClick", function(self) |
|
Util:groupTree(groupTree:GetSelectedGroupInfo(), currentBank, true) |
|
end) |
|
end |
|
|
|
function Util:groupTree(grpInfo, src, all, ah) |
|
local next = next |
|
local newgrp = {} |
|
local totalItems = Util:getTotalItems(src) |
|
local bagItems = Util:getTotalItems("bags") or {} |
|
for groupName, data in pairs(grpInfo) do |
|
groupName = TSMAPI:FormatGroupPath(groupName, true) |
|
for _, opName in ipairs(data.operations) do |
|
TSMAPI:UpdateOperation("Auctioning", opName) |
|
local opSettings = TSM.operations[opName] |
|
|
|
if not opSettings then |
|
-- operation doesn't exist anymore in Auctioning |
|
TSM:Printf(L["'%s' has an Auctioning operation of '%s' which no longer exists."], groupName, opName) |
|
else |
|
--it's a valid operation |
|
for itemString in pairs(data.items) do |
|
local totalq = 0 |
|
local usedq = 0 |
|
local maxPost = opSettings.stackSize * opSettings.postCap |
|
|
|
if totalItems then |
|
totalq = totalItems[itemString] or 0 |
|
end |
|
|
|
if src == "bags" then -- move them all back to bank/gbank |
|
if totalq > 0 then |
|
newgrp[itemString] = totalq * -1 |
|
totalItems[itemString] = nil -- remove the current bag count in case we loop round for another operation |
|
end |
|
else -- move from bank/gbank to bags |
|
if totalq > 0 then |
|
if all then |
|
newgrp[itemString] = totalq |
|
totalq = 0 |
|
else |
|
local quantity = maxPost - (bagItems[itemString] or 0) |
|
newgrp[itemString] = (newgrp[itemString] or 0) + quantity |
|
totalq = totalq - quantity -- remove this operations qty to move from source quantity in case we loop again for another operation |
|
if bagItems[itemString] then --remove this operations maxPost quantity from the bag total in case we loop again for another operation |
|
bagItems[itemString] = bagItems[itemString] - maxPost |
|
if bagItems[itemString] <= 0 then |
|
bagItems[itemString] = nil |
|
end |
|
end |
|
end |
|
end |
|
end |
|
end |
|
end |
|
end |
|
end |
|
|
|
if src ~= "bags" and ah then -- remove ah/mail quantities from the total to move |
|
local playermail = TSMAPI:ModuleAPI("ItemTracker", "playermail") |
|
local playerauctions = TSMAPI:ModuleAPI("ItemTracker", "playerauctions") |
|
for itemString in pairs(newgrp) do |
|
if playerauctions then |
|
newgrp[itemString] = newgrp[itemString] - (playerauctions[itemString] or 0) |
|
end |
|
if playermail then |
|
newgrp[itemString] = newgrp[itemString] - (playermail[itemString] or 0) |
|
end |
|
if newgrp[itemString] < 0 then |
|
newgrp[itemString] = nil |
|
else |
|
-- Get the group's auction operation |
|
local operations = TSMAPI:GetItemOperation(itemString, "Auctioning") |
|
if operations and operations[1] then |
|
local operation = TSM.operations[operations[1]] |
|
if operation then |
|
-- Get the prices |
|
local prices = TSM.Util:GetItemPrices(operation, itemString) |
|
local marketValue = TSMAPI:GetItemValue(itemString, "DBMarket") |
|
local currentMinPrice = TSMAPI:GetItemValue(itemString, "DBMinBuyout") |
|
|
|
-- Compare the prices |
|
if prices.minPrice and prices.maxPrice and prices.normalPrice then |
|
if marketValue and currentMinPrice then |
|
if prices.minPrice > currentMinPrice then |
|
-- Handle the case where the prices do not meet the criteria |
|
-- For example, you can remove the item from the group |
|
newgrp[itemString] = nil |
|
end |
|
end |
|
end |
|
end |
|
end |
|
end |
|
end |
|
end |
|
|
|
if next(newgrp) == nil then |
|
TSM:Print(L["Nothing to Move"]) |
|
else |
|
TSM:Print(L["Preparing to Move"]) |
|
TSMAPI:MoveItems(newgrp, TSM.PrintMsg) |
|
end |
|
end |
|
|
|
function Util:nonGroupTree(grpInfo, src) |
|
local next = next |
|
local newgrp = {} |
|
local bagItems = Util:getTotalItems("bags") |
|
for groupName, data in pairs(grpInfo) do |
|
groupName = TSMAPI:FormatGroupPath(groupName, true) |
|
for _, opName in ipairs(data.operations) do |
|
TSMAPI:UpdateOperation("Auctioning", opName) |
|
local opSettings = TSM.operations[opName] |
|
|
|
if not opSettings then |
|
-- operation doesn't exist anymore in Auctioning |
|
TSM:Printf(L["'%s' has an Auctioning operation of '%s' which no longer exists."], groupName, opName) |
|
else |
|
-- it's a valid operation so remove all the items from bagItems so we are left with non group items to move |
|
for itemString in pairs(data.items) do |
|
if bagItems then |
|
if bagItems[itemString] then |
|
bagItems[itemString] = nil |
|
end |
|
end |
|
end |
|
end |
|
end |
|
end |
|
|
|
|
|
for itemString, quantity in pairs(bagItems) do |
|
quantity = quantity * -1 |
|
if newgrp[itemString] then |
|
newgrp[itemString] = newgrp[itemString] + quantity |
|
else |
|
newgrp[itemString] = quantity |
|
end |
|
end |
|
|
|
if next(newgrp) == nil then |
|
TSM:Print(L["Nothing to Move"]) |
|
else |
|
TSM:Print(L["Preparing to Move"]) |
|
TSMAPI:MoveItems(newgrp, TSM.PrintMsg) |
|
end |
|
end |
|
|
|
function TSM.PrintMsg(message) |
|
TSM:Print(message) |
|
end |
|
|
|
function Util:getTotalItems(src) |
|
local results = {} |
|
if src == "bank" then |
|
local function ScanBankBag(bag) |
|
for slot = 1, GetContainerNumSlots(bag) do |
|
if not TSMAPI:IsSoulbound(bag, slot) then |
|
local itemString = TSMAPI:GetBaseItemString(GetContainerItemLink(bag, slot), true) |
|
if itemString then |
|
local quantity = select(2, GetContainerItemInfo(bag, slot)) |
|
if not results[itemString] then results[itemString] = 0 end |
|
results[itemString] = results[itemString] + quantity |
|
end |
|
end |
|
end |
|
end |
|
|
|
for bag = NUM_BAG_SLOTS + 1, NUM_BAG_SLOTS + NUM_BANKBAGSLOTS do |
|
ScanBankBag(bag) |
|
end |
|
ScanBankBag(-1) |
|
|
|
return results |
|
elseif src == "guildbank" then |
|
for bag = 1, GetNumGuildBankTabs() do |
|
for slot = 1, MAX_GUILDBANK_SLOTS_PER_TAB or 98 do |
|
local link = GetGuildBankItemLink(bag, slot) |
|
local itemString = TSMAPI:GetBaseItemString(link, true) |
|
if itemString then |
|
local quantity = select(2, GetGuildBankItemInfo(bag, slot)) |
|
if not results[itemString] then results[itemString] = 0 end |
|
results[itemString] = results[itemString] + quantity |
|
end |
|
end |
|
end |
|
|
|
return results |
|
elseif src == "bags" then |
|
for bag, slot, itemString, quantity, locked in TSMAPI:GetBagIterator(true) do |
|
if currentBank == "guildbank" then |
|
if not TSMAPI:IsSoulbound(bag, slot) then |
|
results[itemString] = (results[itemString] or 0) + quantity |
|
end |
|
else |
|
results[itemString] = (results[itemString] or 0) + quantity |
|
end |
|
end |
|
end |
|
return results |
|
end |