Guild::BankTab Class Reference

Public Member Functions
	BankTab (uint32 guildId, uint8 tabId)
void	LoadFromDB (Field *fields)
bool	LoadItemFromDB (Field *fields)
void	Delete (CharacterDatabaseTransaction trans, bool removeItemsFromDB=false)
void	SetInfo (std::string_view name, std::string_view icon)
void	SetText (std::string_view text)
void	SendText (const Guild *guild, WorldSession *session) const
std::string const &	GetName () const
std::string const &	GetIcon () const
std::string const &	GetText () const
Item *	GetItem (uint8 slotId) const
bool	SetItem (CharacterDatabaseTransaction trans, uint8 slotId, Item *pItem)

Private Attributes
uint32	m_guildId
uint8	m_tabId
std::array< Item *, GUILD_BANK_MAX_SLOTS >	m_items = {}
std::string	m_name
std::string	m_icon
std::string	m_text

Detailed Description

Constructor & Destructor Documentation

BankTab()

Guild::BankTab::BankTab ( uint32  guildId, uint8  tabId  )

inline

                                             : m_guildId(guildId), m_tabId(tabId)
        {
        }

Member Function Documentation

Delete()

void Guild::BankTab::Delete	(	CharacterDatabaseTransaction	trans,
		bool	removeItemsFromDB = false
	)

{
    for (uint8 slotId = 0; slotId < GUILD_BANK_MAX_SLOTS; ++slotId)
        if (Item* pItem = m_items[slotId])
        {
            pItem->RemoveFromWorld();
            if (removeItemsFromDB)
                pItem->DeleteFromDB(trans);
            delete pItem;
            pItem = nullptr;
        }
}

References GUILD_BANK_MAX_SLOTS.

GetIcon()

std::string const & Guild::BankTab::GetIcon ( ) const

inline

{ return m_icon; }

References m_icon.

Referenced by Guild::HandleSetBankTabInfo().

GetItem()

Item * Guild::BankTab::GetItem ( uint8  slotId ) const

inline

{ return slotId < GUILD_BANK_MAX_SLOTS ?  m_items[slotId] : nullptr; }

References GUILD_BANK_MAX_SLOTS, and m_items.

Referenced by Guild::BankMoveItemData::_StoreItem().

GetName()

std::string const & Guild::BankTab::GetName ( ) const

inline

{ return m_name; }

References m_name.

Referenced by Guild::HandleSetBankTabInfo().

GetText()

std::string const & Guild::BankTab::GetText ( ) const

inline

{ return m_text; }

References m_text.

LoadFromDB()

void Guild::BankTab::LoadFromDB

(

Field *

fields

)

{
    m_name = fields[2].Get<std::string>();
    m_icon = fields[3].Get<std::string>();
    m_text = fields[4].Get<std::string>();
}

References Field::Get(), and Guild::m_name.

LoadItemFromDB()

bool Guild::BankTab::LoadItemFromDB

(

Field *

fields

)

{
    uint8 slotId = fields[13].Get<uint8>();
    ObjectGuid::LowType itemGuid = fields[14].Get<uint32>();
    uint32 itemEntry = fields[15].Get<uint32>();
    if (slotId >= GUILD_BANK_MAX_SLOTS)
    {
        LOG_ERROR("guild", "Invalid slot for item (GUID: {}, id: {}) in guild bank, skipped.", itemGuid, itemEntry);
        return false;
    }
 
    ItemTemplate const* proto = sObjectMgr->GetItemTemplate(itemEntry);
    if (!proto)
    {
        LOG_ERROR("guild", "Unknown item (GUID: {}, id: {}) in guild bank, skipped.", itemGuid, itemEntry);
        return false;
    }
 
    Item* pItem = NewItemOrBag(proto);
    if (!pItem->LoadFromDB(itemGuid, ObjectGuid::Empty, fields, itemEntry))
    {
        LOG_ERROR("guild", "Item (GUID {}, id: {}) not found in item_instance, deleting from guild bank!", itemGuid, itemEntry);
 
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_NONEXISTENT_GUILD_BANK_ITEM);
        stmt->SetData(0, m_guildId);
        stmt->SetData (1, m_tabId);
        stmt->SetData (2, slotId);
        CharacterDatabase.Execute(stmt);
 
        delete pItem;
        return false;
    }
 
    pItem->AddToWorld();
    m_items[slotId] = pItem;
    return true;
}

References Object::AddToWorld(), CHAR_DEL_NONEXISTENT_GUILD_BANK_ITEM, CharacterDatabase, ObjectGuid::Empty, Field::Get(), GUILD_BANK_MAX_SLOTS, Item::LoadFromDB(), LOG_ERROR, NewItemOrBag(), PreparedStatementBase::SetData(), and sObjectMgr.

SendText()

void Guild::BankTab::SendText	(	const Guild *	guild,
		WorldSession *	session
	)		const

{
    WorldPackets::Guild::GuildBankTextQueryResult textQuery;
    textQuery.Tab = m_tabId;
    textQuery.Text = m_text;
 
    if (session)
    {
        LOG_DEBUG("guild", "MSG_QUERY_GUILD_BANK_TEXT [{}]: Tabid: {}, Text: {}"
                       , session->GetPlayerInfo(), m_tabId, m_text);
        session->SendPacket(textQuery.Write());
    }
    else
    {
        LOG_DEBUG("guild", "MSG_QUERY_GUILD_BANK_TEXT [Broadcast]: Tabid: {}, Text: {}", m_tabId, m_text);
        guild->BroadcastPacket(textQuery.Write());
    }
}

References Guild::BroadcastPacket(), WorldSession::GetPlayerInfo(), LOG_DEBUG, WorldSession::SendPacket(), WorldPackets::Guild::GuildBankTextQueryResult::Tab, WorldPackets::Guild::GuildBankTextQueryResult::Text, and WorldPackets::Guild::GuildBankTextQueryResult::Write().

SetInfo()

void Guild::BankTab::SetInfo	(	std::string_view	name,
		std::string_view	icon
	)

{
    if ((m_name == name) && (m_icon == icon))
        return;
 
    m_name = name;
    m_icon = icon;
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GUILD_BANK_TAB_INFO);
    stmt->SetData(0, m_name);
    stmt->SetData(1, m_icon);
    stmt->SetData(2, m_guildId);
    stmt->SetData (3, m_tabId);
    CharacterDatabase.Execute(stmt);
}

References CHAR_UPD_GUILD_BANK_TAB_INFO, CharacterDatabase, Guild::m_name, and PreparedStatementBase::SetData().

Referenced by Guild::HandleSetBankTabInfo().

SetItem()

bool Guild::BankTab::SetItem	(	CharacterDatabaseTransaction	trans,
		uint8	slotId,
		Item *	pItem
	)

{
    if (slotId >= GUILD_BANK_MAX_SLOTS)
        return false;
 
    m_items[slotId] = item;
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_ITEM);
    stmt->SetData(0, m_guildId);
    stmt->SetData (1, m_tabId);
    stmt->SetData (2, slotId);
    CharacterDatabase.ExecuteOrAppend(trans, stmt);
 
    if (item)
    {
        stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_GUILD_BANK_ITEM);
        stmt->SetData(0, m_guildId);
        stmt->SetData (1, m_tabId);
        stmt->SetData (2, slotId);
        stmt->SetData(3, item->GetGUID().GetCounter());
        CharacterDatabase.ExecuteOrAppend(trans, stmt);
 
        item->SetGuidValue(ITEM_FIELD_CONTAINED, ObjectGuid::Empty);
        item->SetGuidValue(ITEM_FIELD_OWNER, ObjectGuid::Empty);
        item->FSetState(ITEM_NEW);
        item->SaveToDB(trans);                                 // Not in inventory and can be saved standalone
    }
    return true;
}

References CHAR_DEL_GUILD_BANK_ITEM, CharacterDatabase, GUILD_BANK_MAX_SLOTS, and PreparedStatementBase::SetData().

Referenced by Guild::BankMoveItemData::_StoreItem().

SetText()

void Guild::BankTab::SetText

(

std::string_view

text

)

{
    if (m_text == text)
        return;
 
    m_text = text;
    utf8truncate(m_text, MAX_GUILD_BANK_TAB_TEXT_LEN);          // DB and client size limitation
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GUILD_BANK_TAB_TEXT);
    stmt->SetData(0, m_text);
    stmt->SetData(1, m_guildId);
    stmt->SetData (2, m_tabId);
    CharacterDatabase.Execute(stmt);
}

References CHAR_UPD_GUILD_BANK_TAB_TEXT, CharacterDatabase, MAX_GUILD_BANK_TAB_TEXT_LEN, PreparedStatementBase::SetData(), and utf8truncate().

Member Data Documentation

m_guildId

uint32 Guild::BankTab::m_guildId

private

m_icon

std::string Guild::BankTab::m_icon

private

Referenced by GetIcon().

m_items

std::array<Item*, GUILD_BANK_MAX_SLOTS> Guild::BankTab::m_items = {}

private

Referenced by GetItem().

m_name

std::string Guild::BankTab::m_name

private

Referenced by GetName().

m_tabId

uint8 Guild::BankTab::m_tabId

private

m_text

std::string Guild::BankTab::m_text

private

Referenced by GetText().