bool
ObjectCache::findStation(Id station_id, Station& station)
{
Station* object = findStation(station_id);
if (object == NULL) return false;
station = *object;
return true;
}
//==============================================================================
bool MinosServerConnection::setFromId( MinosId &id, RPCRequest *req )
{
resubscribed = false;
// and we need to check that the originator is who we think they ought to be
if ( !id.server.size() )
{
logMessage( "ServerSetFromId", "No \"from\" from server " + srv->station );
return false;
}
if ( srv && strcmpi( srv->station.c_str(), id.server.c_str() ) != 0 )
{
logMessage( "ServerSetFromId", "Mismatch from server " + srv->station + " we received \"" + id.server + "\"" );
return false;
}
if ( !srv )
{
// we need to find who is connecting to us
srv = findStation( id.server );
if ( srv )
{
logMessage( "ServerSetFromId", "server " + srv->station + " connected to us" );
}
else
{
logMessage( "ServerSetFromId", "server " + std::string( id.server ) + " tried to connect to us - not recognised" );
// SO we need to set up a server
std::string message;
if (req->getStringArg(1, message))
{
ZConf->setZConfString(message, connectHost);
}
}
}
else
{
logMessage( "ServerSetFromId", std::string( "server " ) + id.server + " connected to us - srv already set up as " + srv->station );
}
clientServer = id.server;
return true;
}
DataObject*
ObjectCache::find(Id object_id, bool cacheOnly)
{
if (object_id == INVALID_ID)
return NULL;
if (_objects.find(object_id) != _objects.end())
return _objects[object_id];
if (cacheOnly)
return NULL;
DataObject object;
if (!_db->lookup(object_id, object))
return NULL;
switch (object.dataType()) {
case DataObject::ACCOUNT: return findAccount(object_id);
case DataObject::ADJUST_REASON: return findAdjustReason(object_id);
case DataObject::CARD_ADJUST: return findCardAdjust(object_id);
case DataObject::CHARGE: return findCharge(object_id);
case DataObject::CHEQUE: return findCheque(object_id);
case DataObject::CLAIM: return findReceive(object_id);
case DataObject::COMPANY: return findCompany(object_id);
case DataObject::COUNT: return findCount(object_id);
case DataObject::CUSTOMER: return findCustomer(object_id);
case DataObject::CUST_TYPE: return findCustomerType(object_id);
case DataObject::DEPT: return findDept(object_id);
case DataObject::DISCOUNT: return findDiscount(object_id);
case DataObject::EMPLOYEE: return findEmployee(object_id);
case DataObject::EXPENSE: return findExpense(object_id);
case DataObject::EXTRA: return findExtra(object_id);
case DataObject::GENERAL: return findGeneral(object_id);
case DataObject::GROUP: return findGroup(object_id);
case DataObject::INVOICE: return findInvoice(object_id);
case DataObject::ITEM: return findItem(object_id);
case DataObject::ITEM_ADJUST: return findItemAdjust(object_id);
case DataObject::ITEM_PRICE: return findItemPrice(object_id);
case DataObject::LABEL_BATCH: return findLabelBatch(object_id);
case DataObject::LOCATION: return findLocation(object_id);
case DataObject::NOSALE: return findNosale(object_id);
case DataObject::ORDER: return findOrder(object_id);
case DataObject::PO_TEMPLATE: return findOrderTemplate(object_id);
case DataObject::PAT_GROUP: return findPatGroup(object_id);
case DataObject::PAT_WS: return findPatWorksheet(object_id);
case DataObject::PAYOUT: return findPayout(object_id);
case DataObject::PERSONAL: return findPersonal(object_id);
case DataObject::PLU: assert("Invalid data type: PLU");
case DataObject::PRICE_BATCH: return findPriceBatch(object_id);
case DataObject::PROMO_BATCH: return findPromoBatch(object_id);
case DataObject::QUOTE: return findQuote(object_id);
case DataObject::RECEIPT: return findReceipt(object_id);
case DataObject::RECEIVE: return findReceive(object_id);
case DataObject::RECONCILE: return findReconcile(object_id);
case DataObject::RECURRING: return findRecurring(object_id);
case DataObject::REPORT: assert("Invalid data type: REPORT");
case DataObject::RETURN: return findInvoice(object_id);
case DataObject::SECURITY_TYPE: return findSecurityType(object_id);
case DataObject::SHIFT: return findShift(object_id);
case DataObject::SLIP: return findSlip(object_id);
case DataObject::STATION: return findStation(object_id);
case DataObject::STORE: return findStore(object_id);
case DataObject::SUBDEPT: return findSubdept(object_id);
case DataObject::TAX: return findTax(object_id);
case DataObject::TENDER: return findTender(object_id);
case DataObject::TEND_COUNT: return findTenderCount(object_id);
case DataObject::TEND_ADJUST: return findTenderAdjust(object_id);
case DataObject::TERM: return findTerm(object_id);
case DataObject::TODO: return findTodo(object_id);
case DataObject::USER: return findUser(object_id);
case DataObject::VENDOR: return findVendor(object_id);
case DataObject::WITHDRAW: return findWithdraw(object_id);
}
qWarning("Unknown object type: " + object.dataTypeName());
return NULL;
}
//==============================================================================
bool MinosServerListener::sendServer( MinosCommonConnection *il, TiXmlElement *tix )
{
MinosId to( getAttribute( tix, "to" ) );
if ( to.server.size() == 0 )
return false;
if ( stricmp( to.server.c_str(), MinosServer::getMinosServer() ->getServerName().c_str() ) == 0 )
return false;
if ( stricmp( to.server.c_str(), DEFAULT_SERVER_NAME ) == 0 )
return false;
// OK, it is not for us... look at connected servers
// bool connect = true;
bool connect = false;
for ( std::vector<MinosSocket *>::iterator i = i_array.begin(); i != i_array.end(); i++ )
{
if ( ( *i ) ->checkServer( to ) && (*i) ->isTxConnection() )
{
if ( !( *i ) ->tryForwardStanza( tix ) )
{
connect = false;
break;
}
return true;
}
}
// send failed; stash the message and initiate a server connection
// (but some stanza types should be ignored?)
if ( connect && MinosServer::getMinosServer() ->getServerName() != DEFAULT_SERVER_NAME )
{
// We need to look at the servers vector, and try to find the relevant one
// If we can't find it, we refuse anyway
Server * srv = findStation( to.server );
if ( srv )
{
// set ourselves up to connect
MinosServerConnection * s = new MinosServerConnection();
if ( s->mConnect( srv ) )
{
connectFreeSlot( s );
// and we need to TRY to resend
if (!s ->tryForwardStanza( tix ))
{
connect = false;
}
return true;
}
else
{
delete s;
// and continue to refuse the message
}
}
}
// server is not connected; REFUSE the message.
// The originator should retry sometime later to send message again
if ( il )
il->sendError( tix, "retry", "item-not-found" ); // deletes pak
return true; // don't pass it on - either we have dealt with it, or its rubbish
}
