302 lines
9.2 KiB
C++
302 lines
9.2 KiB
C++
/**
|
|
* ACCEPTCommand.cc
|
|
*
|
|
* 27/04/2012 - Gergo Focze <gergo_f@yahoo.com>
|
|
* Initial Version.
|
|
*
|
|
* Channel accept command from IRC
|
|
*
|
|
* This program 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 (at your option) any later version.
|
|
*
|
|
* This program 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 this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
|
* USA.
|
|
*/
|
|
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <utility>
|
|
|
|
#include "StringTokenizer.h"
|
|
#include "ELog.h"
|
|
#include "cservice.h"
|
|
#include "dbHandle.h"
|
|
#include "Network.h"
|
|
#include "levels.h"
|
|
#include "responses.h"
|
|
|
|
const char ACCEPTCommand_cc_rcsId[] = "$Id: ACCEPTCommand.cc,v 1.0 2012/04/27 20:48:00 Seven Exp $" ;
|
|
|
|
namespace gnuworld
|
|
{
|
|
using std::pair ;
|
|
using std::string ;
|
|
using std::endl ;
|
|
using std::ends ;
|
|
using std::stringstream ;
|
|
|
|
using namespace gnuworld;
|
|
|
|
bool ACCEPTCommand::Exec( iClient* theClient, const string& Message )
|
|
{
|
|
bot->incStat("COMMANDS.ACCEPT");
|
|
string decision;
|
|
string mngrUserName;
|
|
unsigned int chanId;
|
|
int level = 0;
|
|
|
|
sqlUser* theUser = bot->isAuthed(theClient, true);
|
|
if (theUser) level = bot->getAdminAccessLevel(theUser);
|
|
if (level == 0) return true; //don't show anything to normal users ;)
|
|
StringTokenizer st( Message ) ;
|
|
if ( st.size() < 3 )
|
|
{
|
|
Usage(theClient);
|
|
return true;
|
|
}
|
|
/*
|
|
* Fetch the sqlUser record attached to this client. If there isn't one,
|
|
* they aren't logged in - tell them they should be.
|
|
*/
|
|
|
|
if (!theUser) return false;
|
|
|
|
/* First, check the channel is registered/real. */
|
|
|
|
if ( (st[1][0] != '#') )
|
|
{
|
|
bot->Notice(theClient,
|
|
bot->getResponse(theUser,
|
|
language::inval_chan_name,
|
|
string("Invalid channel name.")));
|
|
return false;
|
|
}
|
|
sqlChannel* theChan = bot->getChannelRecord(st[1]);
|
|
if (theChan)
|
|
{
|
|
bot->Notice(theClient,
|
|
bot->getResponse(theUser,
|
|
language::chan_already_reg,
|
|
string("%s is already registered with me.")).c_str(),
|
|
st[1].c_str());
|
|
return false;
|
|
}
|
|
/* Check the user has sufficient access for this command.. */
|
|
if (level < level::accept)
|
|
{
|
|
bot->Notice(theClient,
|
|
bot->getResponse(theUser,
|
|
language::insuf_access,
|
|
string("You have insufficient access to perform that command.")));
|
|
return false;
|
|
}
|
|
|
|
decision = st.assemble(2);
|
|
if (decision.size() > 300)
|
|
{
|
|
bot->Notice(theClient,"Decision cannot exceed 300 charcters.");
|
|
return false;
|
|
}
|
|
unsigned int lastdays = (unsigned int)bot->currentTime() - ((unsigned int)bot->daySeconds*5);
|
|
stringstream theQuery;
|
|
/********** Channel ID query ***********/
|
|
theQuery << "SELECT id,status FROM channels,pending WHERE "
|
|
<< "channels.registered_ts = 0 AND lower(channels.name) = '"
|
|
<< escapeSQLChars(string_lower(st[1]))
|
|
<< "'"
|
|
<< " AND channels.id = pending.channel_id AND (pending.decision_ts=0 OR (pending.decision_ts>0 AND pending.decision_ts>="
|
|
<< lastdays
|
|
<< "))"
|
|
<< ends;
|
|
if (!bot->SQLDb->Exec(theQuery, true))
|
|
{ bot->logDebugMessage("Error on ACCEPT: channel is not UnClaimed");
|
|
#ifdef LOG_SQL
|
|
//elog << "sqlQuery> " << theQuery.str().c_str() << endl;
|
|
elog << "ACCEPT.pending.status query> SQL Error: "
|
|
<< bot->SQLDb->ErrorMessage()
|
|
<< endl ;
|
|
#endif
|
|
return false;
|
|
} else if (bot->SQLDb->Tuples() == 0)
|
|
{
|
|
bot->Notice(theClient,"Channel %s is not in my applications list",st[1].c_str());
|
|
return false;
|
|
}
|
|
chanId = atoi(bot->SQLDb->GetValue(0,0));
|
|
unsigned short status = atoi(bot->SQLDb->GetValue(0,1));
|
|
if (status == 3) //if we're here, the channel was previously Rejected
|
|
{
|
|
bot->Notice(theClient,"Channel %s is not in my applications list",st[1].c_str());
|
|
return false;
|
|
}
|
|
/* Quick query to set registered_ts back for this chan. */
|
|
stringstream reclaimQuery;
|
|
reclaimQuery << "UPDATE channels SET registered_ts = date_part('epoch', CURRENT_TIMESTAMP)::int,"
|
|
<< " last_updated = date_part('epoch', CURRENT_TIMESTAMP)::int, "
|
|
<< " flags = 0, description = '', url = '', comment = '', keywords = '', channel_mode = '+tn' "
|
|
//<< " WHERE lower(name) = '"
|
|
//<< escapeSQLChars(string_lower(st[1]))
|
|
//<< "'"
|
|
<< " WHERE id = "
|
|
<< chanId
|
|
<< ends;
|
|
|
|
if (!bot->SQLDb->Exec(reclaimQuery))
|
|
{
|
|
bot->logDebugMessage("Error on ACCEPT.UpdateReclaim query");
|
|
#ifdef LOG_SQL
|
|
elog << "sqlQuery> " << reclaimQuery.str().c_str() << endl;
|
|
#endif
|
|
return false;
|
|
}
|
|
/********** Update pending status ***********/
|
|
theQuery.str("");
|
|
theQuery << "UPDATE pending SET status=3,last_updated=date_part('epoch', CURRENT_TIMESTAMP)::int,decision_ts=date_part('epoch', CURRENT_TIMESTAMP)::int,reviewed='Y',decision='"
|
|
<< decision
|
|
<< "',reviewed_by_id="
|
|
<< theUser->getID()
|
|
<<" WHERE channel_id="
|
|
<< chanId
|
|
<< ends;
|
|
if( !bot->SQLDb->Exec(theQuery, true ) )
|
|
{
|
|
bot->logDebugMessage("Error on ACCEPT.UpdatePending query");
|
|
#ifdef LOG_SQL
|
|
elog << "ACCEPT.UpdatePending query> SQL Error: "
|
|
<< bot->SQLDb->ErrorMessage()
|
|
<< endl ;
|
|
#endif
|
|
return false;
|
|
}
|
|
/********** Manager ID query ***********/
|
|
theQuery.str("");
|
|
theQuery << "SELECT manager_id FROM pending WHERE channel_id="
|
|
<< chanId
|
|
<< ends;
|
|
if( !bot->SQLDb->Exec(theQuery, true ) )
|
|
{
|
|
bot->logDebugMessage("Error on ACCEPT.Manager_ID query");
|
|
#ifdef LOG_SQL
|
|
elog << "ACCEPT.Manager_ID query> SQL Error: "
|
|
<< bot->SQLDb->ErrorMessage()
|
|
<< endl ;
|
|
#endif
|
|
return false;
|
|
}
|
|
if (bot->SQLDb->Tuples() == 0)
|
|
{
|
|
bot->logDebugMessage("Result NOT Found ACCEPT.Manager_ID query");
|
|
return false;
|
|
}
|
|
unsigned int mngrId = atoi(bot->SQLDb->GetValue(0,0));
|
|
/********** Update users LastSeen last_updated ***********/
|
|
theQuery.str("");
|
|
theQuery << "UPDATE users_lastseen SET last_updated=date_part('epoch', CURRENT_TIMESTAMP)::int,last_seen=date_part('epoch', CURRENT_TIMESTAMP)::int WHERE user_id="
|
|
<< mngrId
|
|
<< ends;
|
|
if( !bot->SQLDb->Exec(theQuery, true ) )
|
|
{
|
|
bot->logDebugMessage("Error on ACCEPT.UsersLastseen last_updated");
|
|
#ifdef LOG_SQL
|
|
elog << "ACCEPT.UsersLastseen last_updated> SQL Error: "
|
|
<< bot->SQLDb->ErrorMessage()
|
|
<< endl ;
|
|
#endif
|
|
return false;
|
|
}
|
|
/********** Manager username query ***********/
|
|
theQuery.str("");
|
|
theQuery << "SELECT user_name FROM users WHERE id="
|
|
<< mngrId
|
|
<< ends;
|
|
if( !bot->SQLDb->Exec(theQuery, true ) )
|
|
{
|
|
bot->logDebugMessage("Error on ACCEPT.Manager UserName Query");
|
|
#ifdef LOG_SQL
|
|
elog << "ACCEPT.Manager UserName Query> SQL Error: "
|
|
<< bot->SQLDb->ErrorMessage()
|
|
<< endl ;
|
|
#endif
|
|
return false;
|
|
}
|
|
mngrUserName = bot->SQLDb->GetValue(0,0);
|
|
//sqlUser* tmpUser = bot->getUserRecord(mngrUserName);
|
|
/*
|
|
* Create the new channel and insert it into the cache.
|
|
* If the channel exists on IRC, grab the creation timestamp
|
|
* and use this as the channel_ts in the Db.
|
|
*/
|
|
unsigned int channel_ts = 0;
|
|
Channel* tmpChan = Network->findChannel(st[1]);
|
|
channel_ts = tmpChan ? tmpChan->getCreationTime() : ::time(NULL);
|
|
|
|
sqlChannel* newChan = new (std::nothrow) sqlChannel(bot->SQLDb);
|
|
newChan->setName(st[1]);
|
|
newChan->setID(chanId);
|
|
newChan->setChannelTS(channel_ts);
|
|
newChan->setRegisteredTS(bot->currentTime());
|
|
newChan->setChannelMode("+tn");
|
|
newChan->setLastUsed(bot->currentTime());
|
|
|
|
bot->sqlChannelCache.insert(cservice::sqlChannelHashType::value_type(newChan->getName(), newChan));
|
|
bot->sqlChannelIDCache.insert(cservice::sqlChannelIDHashType::value_type(newChan->getID(), newChan));
|
|
|
|
/*
|
|
* Finally, commit a channellog entry.
|
|
*/
|
|
|
|
bot->writeChannelLog(newChan, theClient, sqlChannel::EV_REGISTER, " (*** REGPROC ***) to " + mngrUserName);
|
|
|
|
/*
|
|
* Create the new manager.
|
|
*/
|
|
|
|
sqlLevel* newManager = new (std::nothrow) sqlLevel(bot->SQLDb);
|
|
newManager->setChannelId(newChan->getID());
|
|
newManager->setUserId(mngrId);
|
|
newManager->setAccess(500);
|
|
newManager->setAdded(bot->currentTime());
|
|
newManager->setAddedBy("*** REGPROC ***");
|
|
newManager->setLastModif(bot->currentTime());
|
|
newManager->setLastModifBy("*** REGPROC ***");
|
|
|
|
if (!newManager->insertRecord())
|
|
{
|
|
bot->Notice(theClient, "Couldn't automatically add the level 500 Manager, check it doesn't already exist.");
|
|
delete(newManager);
|
|
return (false);
|
|
}
|
|
|
|
/*
|
|
* Insert this new 500 into the level cache.
|
|
*/
|
|
|
|
pair<int, int> thePair( newManager->getUserId(), newManager->getChannelId());
|
|
bot->sqlLevelCache.insert(cservice::sqlLevelHashType::value_type(thePair, newManager));
|
|
|
|
bot->logAdminMessage("%s (%s) has accepted %s to %s", theClient->getNickName().c_str(),
|
|
theUser->getUserName().c_str(), st[1].c_str(), mngrUserName.c_str());
|
|
bot->Notice(theClient,"Accepted channel %s",st[1].c_str());
|
|
|
|
/* set channel mode R - tmpChan is created further above */
|
|
stringstream tmpTS;
|
|
tmpTS << channel_ts;
|
|
string channelTS = tmpTS.str();
|
|
|
|
if (tmpChan)
|
|
bot->getUplink()->Mode(NULL, tmpChan, string("+R"), channelTS );
|
|
bot->getUplink()->RegisterChannelEvent(st[1],bot);
|
|
return true;
|
|
}
|
|
|
|
} // namespace gnuworld.
|