LSCService Class Reference

#include "LSCService.h"

Inheritance diagram for LSCService:

Collaboration diagram for LSCService:

Public Member Functions
	LSCService (PyServiceMgr *mgr, CommandDispatcher *cd)
	~LSCService ()
void	Init (CommandDispatcher *cd)
PyResult	ExecuteCommand (Client *from, const char *msg)
void	CharacterLogin (Client *pClient)
void	SendServerMOTD (Client *pClient)
void	CreateSystemChannel (int32 channelID)
void	SystemUnload (uint32 systemID, uint32 constID, uint32 regionID)
void	SendMail (uint32 sender, uint32 recipient, const std::string &subject, const std::string &content)
void	SendMail (uint32 sender, const std::vector< int32 > &recipients, const std::string &subject, const std::string &content)
Public Member Functions inherited from PyService
	PyService (PyServiceMgr *mgr, const char *serviceName)
virtual	~PyService ()
virtual PyResult	Call (const std::string &method, PyCallArgs &args)
const char *	GetName () const
Public Member Functions inherited from PyCallable
	PyCallable ()
virtual	~PyCallable ()

Static Public Attributes
static const int32	BASE_CHANNEL_ID = 2100000000
static const uint32	MAX_CHANNEL_ID = 0xFFFFFFFF

Protected Member Functions
	PyCallable_DECL_CALL (GetChannels)
	PyCallable_DECL_CALL (GetRookieHelpChannel)
	PyCallable_DECL_CALL (JoinChannels)
	PyCallable_DECL_CALL (LeaveChannels)
	PyCallable_DECL_CALL (LeaveChannel)
	PyCallable_DECL_CALL (CreateChannel)
	PyCallable_DECL_CALL (Configure)
	PyCallable_DECL_CALL (DestroyChannel)
	PyCallable_DECL_CALL (GetMembers)
	PyCallable_DECL_CALL (GetMember)
	PyCallable_DECL_CALL (SendMessage)
	PyCallable_DECL_CALL (Invite)
	PyCallable_DECL_CALL (AccessControl)
	PyCallable_DECL_CALL (GetMyMessages)
	PyCallable_DECL_CALL (GetMessageDetails)
	PyCallable_DECL_CALL (Page)
	PyCallable_DECL_CALL (MarkMessagesRead)
	PyCallable_DECL_CALL (DeleteMessages)
Protected Member Functions inherited from PyService
PyObject *	_BuildCachedReturn (PySubStream **result, const char *sessionInfo, CacheCheckTime check)
virtual PyBoundObject *	CreateBoundObject (Client *pClient, const PyRep *bind_args)
virtual PyResult	Handle_MachoResolveObject (PyCallArgs &call)
virtual PyResult	Handle_MachoBindObject (PyCallArgs &call)
Protected Member Functions inherited from PyCallable
void	_SetCallDispatcher (CallDispatcher *d)

Protected Attributes
Dispatcher *const	m_dispatch
CommandDispatcher *const	m_commandDispatch
LSCDB *	m_db
std::map< int32, LSCChannel * >	m_channels
Protected Attributes inherited from PyService
PyServiceMgr *const	m_manager

Private Member Functions
void	CreateStaticChannels ()
LSCChannel *	GetChannelByID (int32 channelID)
LSCChannel *	GetChannelByName (std::string channelName)
LSCChannel *	CreateChannel (int32 channelID, uint32 ownerID, const char *name, std::string motd, const char *password, const char *compkey, LSC::Type type=LSC::Type::normal, uint32 cspa=0, int32 groupMessageID=0, int32 channelMessageID=0, bool memberless=false, bool maillist=false, bool temporary=false, bool languageRestriction=false)

Additional Inherited Members
Protected Types inherited from PyService
enum	CacheCheckTime {   check_Always = 0, check_Never, check_in_year, check_in_6_months,   check_in_3_months, check_in_1_month, check_in_1_week, check_in_1_day,   check_in_12_hours, check_in_6_hours, check_in_3_hours, check_in_2_hours,   check_in_1_hour, check_in_30_minutes, check_in_15_minutes, check_in_5_minutes,   check_in_1_minute, check_in_30_seconds, check_in_15_seconds, check_in_5_seconds,   check_in_1_second, _checkCount }
Static Protected Attributes inherited from PyService
static const char *const	s_checkTimeStrings [_checkCount]

Detailed Description

Definition at line 41 of file LSCService.h.

Constructor & Destructor Documentation

LSCService::LSCService	(	PyServiceMgr *	mgr,
		CommandDispatcher *	cd
	)

LSCService::~LSCService

(

)

Definition at line 100 of file LSCService.cpp.

References m_channels, m_db, m_dispatch, and SafeDelete().

                        {
    delete m_dispatch;
    std::map<int32, LSCChannel* >::iterator cur = m_channels.begin();
    for(; cur != m_channels.end(); cur++) {
        SafeDelete(cur->second);
    }
    SafeDelete(m_db);
}

Here is the call graph for this function:

Member Function Documentation

void LSCService::CharacterLogin

(

Client *

pClient

)

Definition at line 907 of file LSCService.cpp.

References CreateSystemChannel(), Client::GetAllianceID(), and Client::GetCorporationID().

Referenced by Client::SelectCharacter().

{
    CreateSystemChannel(pClient->GetCorporationID());
    CreateSystemChannel(pClient->GetAllianceID());
}

Here is the call graph for this function:

Here is the caller graph for this function:

LSCChannel * LSCService::CreateChannel ( int32  channelID, uint32  ownerID, const char *  name, std::string  motd, const char *  password, const char *  compkey, LSC::Type  type = LSC::Type::normal, uint32  cspa = 0, int32  groupMessageID = 0, int32  channelMessageID = 0, bool  memberless = false, bool  maillist = false, bool  temporary = false, bool  languageRestriction = false  )

private

Definition at line 924 of file LSCService.cpp.

References m_channels.

Referenced by CreateStaticChannels(), and CreateSystemChannel().

                                                                                                  {
    // test for invalid channelID (alliance not implemented yet)
    if (channelID == 0)
        return nullptr;

    LSCChannel* channel = new LSCChannel(this, channelID, type, ownerID, name, compkey, motd, memberless, password, maillist, cspa, temporary, languageRestriction, groupMessageID, channelMessageID);
    return (m_channels[channelID] = channel);
}

Here is the caller graph for this function:

void LSCService::CreateStaticChannels ( )

private

Definition at line 1034 of file LSCService.cpp.

References CreateChannel(), cspa, LSC::custom, and LSC::normal.

                                      {
    // hardcode creating server static channels during server startup
    // these are all set to memberless to avoid constant updates
    std::ostringstream str;

// basic template
    //CreateChannel(channelID, ownerID, "name", "motd", "password" or nullptr, "*title*", LSC::Type::normal, cspa, 0, 0, true);

//Help
// Incursion Rookie Help MOTD
    str.str("");
    str << "<br><color=0xff007fff><b>Welcome to the EVEmu <u>EVE Online: Crucible</u> Emulator</b></color><br><br>";
    str << "<color=0xff00ff00><b>Topic:</b></color>  ";
    str << "<color=0xffffffff>EVE-Online related rookie help.</color><br><br>";
    str << "<color=0xff00ff00><b>Rules:</b></color>  ";
    str << "<color=0xffffffff>No WTB, WTS, WTT, PC, advertising, recruiting, scamming, offering private help in any form or begging in this channel.<br>";
    str << "No CAPS or text-decoration.</color><br><br>";
    str << "<color=0xff00ff00><b>Language:</b></color>  ";
    str << "<color=0xffffffff>This channel is ENGLISH ONLY.</color><br><br>";
    str << "<color=0xff00ff00><b>How to contact a GM:</b> </color>  ";
    str << "<color=0xffffffff>Right now, our petition service isnt operational, so to contact a GM, post on the forums.</color><br><br>";
    //str << "<color=0xffffffff>File a petition (F12 - Petitions - New Petition)</color><br><br>";
    str << "<color=0xff00ff00><b>ISK Advertising:</b></color>  ";
    str << "<color=0xffff0000>Contrary to what they spam, EVEmu does not authorize any person or site to sell ISK for RL cash.</color><br><br>";
    str << "<color=0xff00ff00><b>Please Note:</b></color><br>";
    str << "<color=0xffffffff>There are no third party applications (.exe) that will magically give you any type of ship you wish or hack your wallet. Please report characters advertising these types of links IMMEDIATELY via petition and DO NOT download and try them. <br><br>";
    // str << "Sister of EVE storyline starts in <url=showinfo:5//30005001><u>Arnon</url></b></u> <b>with <url=showinfo:1378//3019356><u>Sister Alitura</url></b></u>. <br><br></color>";
    CreateChannel(1, 1, "Rookie Help", str.str().c_str(), nullptr, "help", LSC::Type::normal, cspa, 263238, -1, true);
// Incursion Help MOTD
    str.str("");
    str << "<br><color=0xff007fff><b>Welcome to the EVEmu <u>EVE Online: Crucible</u> Emulator</color><br><br>";
    str << "<color=0xff00ff00><b>Topic:</b></color>  ";
    str << "<color=0xffffffff>EVE-Online related help.</color><br><br>";
    str << "<color=0xff00ff00><b>Rules:</b></color>  ";
    str << "<color=0xffffffff>No WTB, WTS, WTT, PC, advertising, recruiting, scamming, offering private help in any form or begging in this channel.<br>";
    str << "No CAPS or text-decoration.</color><br><br>";
    str << "<color=0xff00ff00><b>Language:</b></color>  ";
    str << "<color=0xffffffff>This channel is ENGLISH ONLY.</color><br><br>";
    str << "<color=0xff00ff00><b>How to contact a GM:</b> </color>  ";
    str << "<color=0xffffffff>Right now, our petition service isnt operational, so to contact a GM, post on the forums.</color><br><br>";
    //str << "<color=0xffffffff>File a petition (F12 - Petitions - New Petition)</color><br><br>";
    str << "<color=0xff00ff00><b>ISK Advertising:</b></color>  ";
    str << "<color=0xffff0000>Contrary to what they spam, EVEmu does not authorize any person or site to sell ISK for RL cash.</color><br><br>";
    CreateChannel(2, 1, "Help", str.str().c_str(), nullptr, "help", LSC::Type::normal, cspa, 263238, -1/*263262*/, true);
//Empires/Factions
    CreateChannel(10, 1, "Caldari", "Caldari Faction", nullptr, "caldari", LSC::Type::normal, cspa, 263329, -1/*263268*/, true);
    CreateChannel(11, 1, "Amarr", "Amarr Faction", nullptr, "amarr", LSC::Type::normal, cspa, 263329, -1/*263246*/, true);
    CreateChannel(12, 1, "Minmatar", "Minmatar Faction", nullptr, "minmatar", LSC::Type::normal, cspa, 263329, -1/*263281*/, true);
    CreateChannel(13, 1, "Gallente", "Gallente Faction", nullptr, "gallente", LSC::Type::normal, cspa, 263329, -1/*263271*/, true);
    CreateChannel(14, 1, "Jove", "Jove Faction", nullptr, "jove", LSC::Type::normal, cspa, 263329, -1/*263258*/, true);
// Incursion recruitment MOTD...
    str.str("");
    str << "<br><color=0xffffffff>Welcome to the recruitment channel.<br><br>";
    str << "This channel is intended for those players looking to find a new corporation, as well as those looking to enlist new players.<br>";
    str << "Other activities, such as non-recruitment discussion and scamming, are not permitted in this channel.";
//Corporate
    CreateChannel(20, 9, "Recruitment", str.str().c_str(), nullptr, "recruitment", LSC::Type::normal, cspa, 263235, -1/*263286*/, true);
    str.str("");
    str << "<br><color=0xffffffff>Welcome to this</color> <color=0xff00ffff>Corporate CEO</color><color=0xffffffff> channel.<br><br>";
    str << "This channel is intended for corp CEOs to discuss business as they see fit.</color>";
    CreateChannel(21, 9, "CEO", str.str().c_str(), nullptr, "ceo", LSC::Type::normal, cspa, 263235, -1/*263287*/, true);
//Alliance
    /*
    str.str("");
    str << "<color=0xffffffff>Welcome to this</color> <color=0xff00ffff>Alliance</color><color=0xffffffff>  channel.  This channel is intended for corp CEOs to discuss business as they see fit.</color>";
    CreateChannel(31, 1, "Smacktalk", str.str().c_str(), nullptr, "smacktalk", LSC::Type::normal, cspa, 263330, -1, true);
    CreateChannel(32, 1, "Rumour Mill", str.str().c_str(), nullptr, "rumourmill", LSC::Type::normal, cspa, 263330, -1, true);
    CreateChannel(33, 1, "Freelancer", str.str().c_str(), nullptr, "freelancer", LSC::Type::normal, cspa, 263330, -1, true);
    */
//Trade
    str.str("");
    str << "<br><color=0xffffffff>Welcome to this</color> <color=0xff00ffff>Trade</color><color=0xffffffff> channel.<br><br>";
    str << "This channel is intended for those players looking to trade the various items as referenced in the channel title.</color>";
    CreateChannel(40, 1, "Other", str.str().c_str(), nullptr, "other", LSC::Type::normal, cspa, 263240, -1/*263277*/, true);
    CreateChannel(41, 1, "Ships", str.str().c_str(), nullptr, "ships", LSC::Type::normal, cspa, 263240, -1/*263245*/, true);
    CreateChannel(42, 1, "Blueprints", str.str().c_str(), nullptr, "blueprints", LSC::Type::normal, cspa, 263240, -1/*263292*/, true);
    CreateChannel(43, 1, "Modules and Munitions", str.str().c_str(), nullptr, "modulesandmunitions", LSC::Type::normal, cspa, 263240, -1/*263254*/, true);
    CreateChannel(44, 1, "Minerals and Manufacturing", str.str().c_str(), nullptr, "mineralsandmanufacturing", LSC::Type::normal, cspa, 263240, -1/*263275*/, true);
//Science and Industry
    str.str("");
    str << "<br><color=0xffffffff>Welcome to this</color> <color=0xff00ffff>Science and Industry</color><color=0xffffffff> channel.<br><br>";
    str << "This channel is intended for those players looking to discuss the various items as referenced in the channel title.</color>";
    CreateChannel(50, 1, "Boosters", str.str().c_str(), nullptr, "boosters", LSC::Type::normal, cspa, 263331, -1/*263365*/, true);
    CreateChannel(51, 1, "Invention", str.str().c_str(), nullptr, "invention", LSC::Type::normal, cspa, 263331, -1/*263366*/, true);
    CreateChannel(52, 1, "Manufacturing", str.str().c_str(), nullptr, "manufacturing", LSC::Type::normal, cspa, 263331, -1/*263367*/, true);
    CreateChannel(53, 1, "Mining", str.str().c_str(), nullptr, "mining", LSC::Type::normal, cspa, 263331, -1/*263368*/, true);
    CreateChannel(54, 1, "Planetary Interaction", str.str().c_str(), nullptr, "planetaryinteraction", LSC::Type::normal, cspa, 263331, -1/*263369*/, true);
    CreateChannel(55, 1, "Research", str.str().c_str(), nullptr, "research", LSC::Type::normal, cspa, 263331, -1/*263370*/, true);
//Groups/Content
    str.str("");
    str << "<br><color=0xffffffff>Welcome to this</color> <color=0xff00ffff>Content</color><color=0xffffffff> channel.<br><br>";
    str << "This channel is intended for those players looking to discuss the various items as referenced in the channel title.</color>";
    CreateChannel(60, 1, "Incursions", str.str().c_str(), nullptr, "incursions", LSC::Type::normal, cspa, 263328, -1/*263289*/, true);
    CreateChannel(61, 1, "Ratting", str.str().c_str(), nullptr, "ratting", LSC::Type::normal, cspa, 263328, -1/*263338*/, true);
    CreateChannel(62, 1, "Scanning", str.str().c_str(), nullptr, "scanning", LSC::Type::normal, cspa, 263328, -1/*263339*/, true);
    CreateChannel(63, 1, "Wormholes", str.str().c_str(), nullptr, "wormholes", LSC::Type::normal, cspa, 263328, -1/*263340*/, true);
//Misc
    str.str("");
    str << "<br><color=0xffffffff>Welcome to the <url=https://evemu.dev>Free Wrecks</url> channel.<br>";
    str << "Here you can offer your abandoned mission wrecks to any willing freelance salvager in New Eden.</color><br><br>";
    str << "<b><u><color=0xff00ffff>Salvagers</color></u><br><color=0xff00ff00>Alphas</color></b>";
    str << "<color=0xffffffff> - Basic salvage fits by race: </color><br>";
    str << "<url=fitting:16236:31083;2:25861;4:8135;1:31370;1:1319;2:4435;1:5973;1:24348;4::>Amarr</url><color=0xffffffff> - </color>";
    str << "<url=fitting:16238:25861;4:1319;2:31370;1:31083;2:4435;2:5973;1:24348;4::>Caldari</url><color=0xffffffff> - </color>";
    str << "<url=fitting:16240:31083;2:25861;4:8135;1:31370;1:1319;2:4435;1:5973;1:24348;4::>Gallente</url><color=0xffffffff> - </color>";
    str << "<url=fitting:16242:25861;4:1319;2:31370;1:31083;2:6001;1:4435;2:24348;4::>Minmatar</url><color=0xffffffff> </color><br><br>";
    /*  this suggests t2 shit which isnt available yet
    str << "<b><color=0xff00ff00>Omegas</color></b><color=0xffffffff> - You should be able to use a </color><url=showinfo:2998>Noctis</url>";
    str << "<color=0xffffffff>, </color><url=showinfo:30836>Salvager II's</url><color=0xffffffff> &amp; </color><url=showinfo:4250>Tractor Beam II's</url><br>";
    */
    str << "<b><u><color=0xff00ffff>Mission Runners</color></b></u><br><color=0xffffffff>";
    str << "Please state where your bookmark will be traded, contracted or if you're hoping to fleet with the salvager looking for work. <br>";
    str << "If you are contracting or trading bookmarks dont forget to</color> <color=0xff007fff>Abandon all wrecks and containers</color><color=0xffffffff>.</color><br><br>";
    str << "<b><u><color=0xff00ff00>Useful Links.</color></u><br>";
    str << "<loc><url=http://evemaps.dotlan.net/>DOTLAN</url></loc></b><color=0xffffffff> - A database of everything you need to know about New Eden; maps, corporations, navigations and much more.</color><color=0xff0000ff>NOTE:</color><color=0xffffffff> While this site is specific for Tranquility, the maps and navigation are the same here on EVEmu.</color><br>";
    str << "<loc><url=http://o.smium.org>Osmium</url></loc><color=0xffffffff> - A site where pilots post their ship fittings to help players get the most out of their ship class.</color><br>";
    str << "<loc><url=http://eve-survival.org/wikka.php?wakka=MissionReports>EVE Survival</url></loc><color=0xffffffff> - A database of missions within New Eden. Here you can find information about gaining the upper hand on those sneaky NPCs and how to perfectly run the mission in question.</color><br>";
    str << "<loc><url=http://www.fuzzwork.co.uk/>Fuzz Work</url></loc><color=0xffffffff> - A brilliant site that has many awesome calculators for LP stores, Blueprints, Invention, Ore and much more!</color><br>";
    CreateChannel(100, 2, "Free Wrecks", str.str().c_str(), nullptr, "freewrecks", LSC::Type::normal, cspa, 0, 0, true); //256739 <-- this was messageID from error about "channel already joined"
    //CreateChannel(101, 1, "", "motd", nullptr, "*title*", LSC::Type::normal, cspa, 0, 0, true);

//GM Command channel
    str.str("");
    str << "<br><color=0xffffffff>Welcome to the</color> <color=0xff00ffff>GM Command</color><color=0xffffffff> channel.<br><br>";
    str << "This channel is intended for using dot commands.</color>";
    CreateChannel(2900000000, 1, "Command", str.str().c_str(), nullptr, "command", LSC::Type::custom, cspa, 0, 0, true);
}

Here is the call graph for this function:

void LSCService::CreateSystemChannel

(

int32

channelID

)

Todo:

i know this isnt used much, but wtf was i thinking hitting db for names, when they are in static data??

Definition at line 951 of file LSCService.cpp.

References LSC::alliance, LSC::constellation, LSC::corp, CreateChannel(), cspa, LSC::fleet, LSCDB::GetAllianceName(), LSCDB::GetConstellationName(), LSCDB::GetCorporationName(), LSCDB::GetRegionName(), LSCDB::GetSolarSystemName(), IsAlliance, IsConstellationID, IsFleetID, IsKSpaceID, IsNPCCorp, IsPlayerCorp, IsRegionID, IsSquadID, IsWingID, IsWSpaceID, m_channels, m_db, LSC::normal, LSC::region, sFltSvc, LSC::solarsystem, LSC::solarsystem2, LSC::squad, and LSC::wing.

Referenced by SystemManager::BootSystem(), CharacterLogin(), FleetService::CreateFleet(), FleetService::CreateSquad(), and FleetService::CreateWing().

{
    if (channelID == 0)
        return;
    if (m_channels.find(channelID) != m_channels.end())
        return;

    LSC::Type type = LSC::Type::normal;
    std::string name= "", motd = "";
    int32 messageID = -1, grpMsgID = 0;
    uint32 ownerID = channelID;

    if (IsRegionID(channelID)) {
        type = LSC::Type::region;
        name = "Region";
        motd = m_db->GetRegionName(channelID);
        grpMsgID = 1;
    } else if (IsConstellationID(channelID)) {
        type = LSC::Type::constellation;
        name = "Constellation";
        motd = m_db->GetConstellationName(channelID);
        grpMsgID = 2;
    } else if (IsKSpaceID(channelID)) {
        type = LSC::Type::solarsystem2;
        name = "Local";
        motd = m_db->GetSolarSystemName(channelID);
        grpMsgID = 3;
    } else if (IsWSpaceID(channelID)) {
        type = LSC::Type::solarsystem;
        name = "System";
        motd = m_db->GetSolarSystemName(channelID);
        grpMsgID = 3;
    } else if (IsNPCCorp(channelID)) {
        type = LSC::Type::corp;
        name = "Corp";
        motd = m_db->GetCorporationName(channelID);
        grpMsgID = 263235;
    } else if (IsPlayerCorp(channelID)) {
        type = LSC::Type::corp;
        name = "Corp";
        motd = m_db->GetCorporationName(channelID);
        grpMsgID = 263235;
        messageID = 0;
    } else if (IsAlliance(channelID)) {
        type = LSC::Type::alliance;
        name = "Alliance";
        motd = m_db->GetAllianceName(channelID);
        grpMsgID = 5;
        messageID = 0;
    } else if (IsFleetID(channelID)) {
        type = LSC::Type::fleet;
        name = sFltSvc.GetFleetName(channelID);
        motd = sFltSvc.GetFleetDescription(channelID);
        messageID = 0;
        ownerID = sFltSvc.GetFleetLeaderID(channelID);
    } else if (IsWingID(channelID)) {
        type = LSC::Type::wing;
        name = sFltSvc.GetWingName(channelID);
        motd = name;
        motd += "<br>";
        motd += sFltSvc.GetFleetDescription(channelID);
        messageID = 0;
        //ownerID = sFltSvc.GetWingLeaderID(channelID);
        ownerID = sFltSvc.GetFleetLeaderID(channelID);
    } else if (IsSquadID(channelID)) {
        type = LSC::Type::squad;
        name = sFltSvc.GetSquadName(channelID);
        motd = name;
        motd += "<br>";
        motd += sFltSvc.GetFleetDescription(channelID);
        messageID = 0;
        //ownerID = sFltSvc.GetSquadLeaderID(channelID);
        ownerID = sFltSvc.GetFleetLeaderID(channelID);
    } else {
        // not sure what to do here....should never hit
    }
    std::string comStr = motd;
    boost::algorithm::to_lower(comStr);
    comStr.erase(std::remove(comStr.begin(), comStr.end(), ' '), comStr.end());
    CreateChannel(channelID, ownerID, name.c_str(), motd, nullptr, comStr.c_str(), type, cspa, grpMsgID, messageID);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyResult LSCService::ExecuteCommand	(	Client *	from,
		const char *	msg
	)

Definition at line 1304 of file LSCService.cpp.

References CommandDispatcher::Execute(), and m_commandDispatch.

                                                                 {
    return(m_commandDispatch->Execute(from, msg));
}

Here is the call graph for this function:

LSCChannel * LSCService::GetChannelByID ( int32  channelID )

private

Definition at line 935 of file LSCService.cpp.

References m_channels.

{
    std::map<int32, LSCChannel*>::iterator itr = m_channels.find(channelID);
    if (itr != m_channels.end())
        return itr->second;
    return nullptr;
}

LSCChannel * LSCService::GetChannelByName ( std::string  channelName )

private

Definition at line 943 of file LSCService.cpp.

References m_channels.

{
    for (auto cur : m_channels)
        if (cur.second->GetDisplayName() == channelName)
            return cur.second;
    return nullptr;
}

void LSCService::Init

(

CommandDispatcher *

cd

)

Definition at line 109 of file LSCService.cpp.

{

}

LSCService::PyCallable_DECL_CALL ( GetChannels  )

protected

LSCService::PyCallable_DECL_CALL ( GetRookieHelpChannel  )

protected

LSCService::PyCallable_DECL_CALL ( JoinChannels  )

protected

LSCService::PyCallable_DECL_CALL ( LeaveChannels  )

protected

LSCService::PyCallable_DECL_CALL ( LeaveChannel  )

protected

LSCService::PyCallable_DECL_CALL ( CreateChannel  )

protected

LSCService::PyCallable_DECL_CALL ( Configure  )

protected

LSCService::PyCallable_DECL_CALL ( DestroyChannel  )

protected

LSCService::PyCallable_DECL_CALL ( GetMembers  )

protected

LSCService::PyCallable_DECL_CALL ( GetMember  )

protected

LSCService::PyCallable_DECL_CALL ( SendMessage  )

protected

LSCService::PyCallable_DECL_CALL ( Invite  )

protected

LSCService::PyCallable_DECL_CALL ( AccessControl  )

protected

LSCService::PyCallable_DECL_CALL ( GetMyMessages  )

protected

LSCService::PyCallable_DECL_CALL ( GetMessageDetails  )

protected

LSCService::PyCallable_DECL_CALL ( Page  )

protected

LSCService::PyCallable_DECL_CALL ( MarkMessagesRead  )

protected

LSCService::PyCallable_DECL_CALL ( DeleteMessages  )

protected

void LSCService::SendMail ( uint32  sender, uint32  recipient, const std::string &  subject, const std::string &  content  )

inline

Definition at line 64 of file LSCService.h.

Referenced by Client::SelfEveMail().

                                                                                                       {
        std::vector<int32> recs(1, recipient);
        SendMail(sender, recs, subject, content);
    }

Here is the caller graph for this function:

void LSCService::SendMail	(	uint32	sender,
		const std::vector< int32 > &	recipients,
		const std::string &	subject,
		const std::string &	content
	)

Definition at line 1209 of file LSCService.cpp.

References _log, m_db, sEntityList, LSCDB::StoreMail(), and Win32TimeNow().

                                                                                                                               {
    NotifyOnMessage notify;
    std::set<uint32> successful_recipients;

    notify.subject = subject;
    notify.sentTime = Win32TimeNow();
    notify.senderID = sender;

    // there's attachmentID and messageID... does this means a single message can contain multiple attachments?
    // eg. text/plain and text/html? we should be watching for this at reading mails...
    // created should be creation time. But Win32TimeNow returns int64, and is stored as bigint(20),
    // so change in the db is needed
    std::vector<int32>::const_iterator cur, end;
    cur = recipients.begin();
    end = recipients.end();

    for(; cur != end; cur++) {
        uint32 messageID = m_db->StoreMail(sender, *cur, subject.c_str(), content.c_str(), notify.sentTime);
        if(messageID == 0) {
            _log(SERVICE__ERROR, "Failed to store message from %u for recipient %u", sender, *cur);
            continue;
        }
        //TODO: supposed to have a different messageID in each notify I suspect..
        notify.messageID = messageID;

        _log(SERVICE__MESSAGE, "Delivered message from %u to recipient %u", sender, *cur);
        //record this person in the 'delivered to' list:
        notify.recipients.push_back(*cur);
        successful_recipients.insert(*cur);
    }

    //now, send a notification to each successful recipient
    PyTuple *answer = notify.Encode();
    sEntityList.Multicast(successful_recipients, "OnMessage", "*multicastID", &answer, false);
}

Here is the call graph for this function:

void LSCService::SendServerMOTD

(

Client *

pClient

)

Definition at line 1162 of file LSCService.cpp.

References Client::GetSystemID(), and m_channels.

Referenced by Client::SelectCharacter().

{
    std::map<int32, LSCChannel*>::iterator itr = m_channels.find(pClient->GetSystemID());
    if (itr != m_channels.end())
        itr->second->SendServerMOTD(pClient);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void LSCService::SystemUnload	(	uint32	systemID,
		uint32	constID,
		uint32	regionID
	)

Todo:

find a way to track usages of region and const channels to delete when no longer used

Definition at line 913 of file LSCService.cpp.

References m_channels, and SafeDelete().

Referenced by SystemManager::UnloadSystem().

{
    std::map<int32, LSCChannel*>::iterator itr = m_channels.find(systemID);
    if (itr != m_channels.end()) {
        SafeDelete(itr->second);
        m_channels.erase(itr);
    }
    //  is this needed?
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

const int32 LSCService::BASE_CHANNEL_ID = 2100000000

static

Todo:

LSC system todo list... to implement... channel password private chat invite more

to fix... channelID system more

fleet shit... BOSS/FC/WC/SC should be able to moderate text in their respective fleet chat as needed. They should have the power to dictate text color of their type, and silence people who shouldn't be talking..

Definition at line 48 of file LSCService.h.

Referenced by LSCDB::GetNextAvailableChannelID().

std::map<int32, LSCChannel*> LSCService::m_channels

protected

Definition at line 77 of file LSCService.h.

Referenced by CreateChannel(), CreateSystemChannel(), GetChannelByID(), GetChannelByName(), SendServerMOTD(), SystemUnload(), and ~LSCService().

CommandDispatcher* const LSCService::m_commandDispatch

protected

Definition at line 73 of file LSCService.h.

Referenced by ExecuteCommand().

LSCDB* LSCService::m_db

protected

Definition at line 75 of file LSCService.h.

Referenced by CreateSystemChannel(), SendMail(), and ~LSCService().

Dispatcher* const LSCService::m_dispatch

protected

Definition at line 71 of file LSCService.h.

Referenced by ~LSCService().

const uint32 LSCService::MAX_CHANNEL_ID = 0xFFFFFFFF

static

Definition at line 49 of file LSCService.h.

Referenced by LSCDB::GetNextAvailableChannelID().

---

The documentation for this class was generated from the following files:

• /backups/local/src/eve/EvEmu_Crucible/src/eve-server/chat/LSCService.h
• /backups/local/src/eve/EvEmu_Crucible/src/eve-server/chat/LSCService.cpp