tmwserv/src/account-server/dalstorage.hpp

/*
 *  The Mana World Server
 *  Copyright 2004 The Mana World Development Team
 *
 *  This file is part of The Mana World.
 *
 *  The Mana World  is free software; you can redistribute  it and/or modify it
 *  under the terms of the GNU General  Public License as published by the Free
 *  Software Foundation; either version 2 of the License, or any later version.
 *
 *  The Mana  World is  distributed in  the hope  that it  will be  useful, but
 *  WITHOUT ANY WARRANTY; without even  the implied warranty of MERCHANTABILITY
 *  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 *  more details.
 *
 *  You should  have received a  copy of the  GNU General Public  License along
 *  with The Mana  World; if not, write to the  Free Software Foundation, Inc.,
 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#ifndef _TMWSERV_DALSTORAGE_H_
#define _TMWSERV_DALSTORAGE_H_

#include <list>
#include <map>
#include <vector>

#include "../dal/dataprovider.h"

#include "../common/transaction.hpp"

class Account;
class Character;
class ChatChannel;
class Guild;
class Letter;
class Post;

class DALStorage
{
    public:
        DALStorage();


        ~DALStorage();


        void open();


        void close();


        Account *getAccount(const std::string& userName);

        Account *getAccount(int accountID);

        Character *getCharacter(int id, Account *owner);

        Character *getCharacter(const std::string &name);

        void
        addAccount(Account *account);

        void delAccount(Account *account);

        void updateLastLogin(const Account *account);

        void updateCharacterPoints(const int CharId, const int CharPoints,
            const int CorrPoints, const int AttribId, const int AttribValue );

        void updateExperience(const int CharId, const int SkillId,
            const int SkillValue);

        void banCharacter(int id, int duration);

        void delCharacter(int charId, bool startTransaction) const;

        void delCharacter(Character *character, bool startTransaction) const;

        void checkBannedAccounts();

        bool doesUserNameExist(const std::string &name);

        bool doesEmailAddressExist(const std::string &email);

        bool doesCharacterNameExist(const std::string &name);

        bool
        updateCharacter(Character *ptr,
                        bool startTransaction = true);

        void
        flushSkill(const Character* const character, const int skill_id );

        void
        addGuild(Guild* guild);

        void
        removeGuild(Guild* guild);

        void
        addGuildMember(int guild_id, int memberId);

        void
        removeGuildMember(int guildId, int memberId);

        void
        setMemberRights(int guildId, int memberId, int rights);

        std::list<Guild*>
        getGuildList();

        void flushAll();
        void flush(Account *);

        std::string getQuestVar(int id, const std::string &);

        void setQuestVar(int id, const std::string &, const std::string &);

        std::string getWorldStateVar(const std::string &name, int map_id = -1);

        void setWorldStateVar(const std::string &name, const std::string &value);

        void setWorldStateVar(const std::string &name, int map_id,
                              const std::string &value);

        void setAccountLevel(int id, int level);

        void setPlayerLevel(int id, int level);

        void storeLetter(Letter *letter);

        Post* getStoredPost(int playerId);

        void deletePost(Letter* letter);

        void addAuctionItem(unsigned int itemId, int playerId, unsigned int gold);

        unsigned int getItemDatabaseVersion(void) const
        { return mItemDbVersion; }

        void setOnlineStatus(int charId, bool online);

        void addTransaction(const Transaction &trans);

        std::vector<Transaction> getTransactions(unsigned int num);
        std::vector<Transaction> getTransactions(time_t date);

    private:
        DALStorage(const DALStorage& rhs);


        DALStorage&
        operator=(const DALStorage& rhs);

        Account *getAccountBySQL(const std::string &query);


        Character *getCharacterBySQL(const std::string &query, Account *owner);

        void SyncDatabase(void);

        dal::DataProvider *mDb; 
        unsigned int mItemDbVersion;    
};

extern DALStorage *storage;

#endif // _TMWSERV_DALSTORAGE_H_

---