void deleteAccount(List* list, int i){
Account* toDelete = getAccount(list,i);
toDelete->next->prev = toDelete->prev;
toDelete->prev->next = toDelete->next;
free(toDelete);
list->size--;
}
// Rename account
mpapo::Account Account::renameAccount( int accountId , int accountVersionToRename , string newAccountName )
{
//MPA_LOG_TRIVIAL( trace , "Start" );
try
{
mpapo::Account account = getAccount( accountId );
if( account.isCorrectVersion( accountVersionToRename ) )
{
account.setName( newAccountName );
account.updateVersion();
account.update();
//MPA_LOG_TRIVIAL( trace , "End" );
// Return is here because there is no empty constructor for mpapo::Account::Account()
return account;
}
else throw MPA::getErrMsg( 4 );
}
catch (NotFound & e)
{
throw MPA::getErrMsg( 2 );
}
}
bool Account::delAccount(int id , int version )
{
bool ret = false;
MPA_LOG_TRIVIAL(trace,"Account to delete:" + StrUtil::int2string( id )+" with version: " + StrUtil::int2string(version ));
try
{
mpapo::Account accountToDel = getAccount( id );
if( accountToDel.isCorrectVersion( version ) )
{
MPA_LOG_TRIVIAL(trace,"Account found");
if( accountToDel.operations().get().all().size() > 0 ) throw MPA::getErrMsg( MSG_DEL_IMPOSSIBLE_OPERATIONS );
if( accountToDel.providers().get().all().size() > 0 ) throw MPA::getErrMsg( MSG_DEL_IMPOSSIBLE_PROVIDERS );
if( accountToDel.categories().get().all().size() > 0 ) throw MPA::getErrMsg( MSG_DEL_IMPOSSIBLE_CATEGORIES );
MPA::getInstance()->getMPAPO().begin();
accountToDel.del();
MPA::getInstance()->getMPAPO().commit();
}
else throw MPA::getErrMsg( 4 );
}
catch (NotFound & e)
{
throw MPA::getErrMsg( 2 );
}
return ret;
}
bool BankDatabase::authenticateUser(int accountNumber, int password){
try{
Account *acc = getAccount(accountNumber);
return acc->checkPassword(password);
}
catch (char *){ //null값이 리턴된것을 전파받았을 경우에 false반환(예외처리)
return false;
}
}
void
AccountFactory::removeAccount(const std::string& id)
{
std::lock_guard<std::recursive_mutex> lock(mutex_);
if (auto account = getAccount(id)) {
removeAccount(*account);
} else
RING_ERR("No account with ID %s", id.c_str());
}
// determine if account number and PIN match
// those of an account in the database
bool BankDatabase::authenticateUser(int userAccountNumber, int userPIN)
{
// attempt to retrieve the account with the account number
Account* const userAccountPtr = getAccount(userAccountNumber);
// if account exists, return result of Account function validatePIN
if (userAccountPtr != NULL)
return userAccountPtr->validatePIN(userPIN);
else
return false; // account number not found, so return false
}
QList<Account*> accountmanagerdialog::getAccounts()
{
QList<Account*> accounts = QList<Account*>();
int numItems = ui->listWidget->count();
for(int i=0;i<numItems;i++) {
Account *acc = getAccount(ui->listWidget->item(i));
accounts.append(acc);
}
return accounts;
}
void accountmanagerdialog::on_editButton_clicked()
{
QList<QListWidgetItem*> selected = ui->listWidget->selectedItems();
if(selected.isEmpty())
return;
QListWidgetItem *thisOne = selected.first();
Account *acc = getAccount(thisOne);
AccountDialog *accDiag = new AccountDialog(0,acc);
accDiag->exec();
}
/*
* === FUNCTION ======================================================================
* Name: initial
* Description:
* =====================================================================================
*/
void
initial ( )
{
int i = 0;
printf ( "The initial step\n" );
getAccount();
for ( i = 0; i<userCanHandle ; i++ ) {
allUsers[i].stage = offLine;
allUsers[i].socket = -1;
allUsers[i].serverCache = i ;
}
return ;
} /* ----- end of function initial ----- */
void accountmanagerdialog::on_toggleButton_clicked()
{
QList<QListWidgetItem*> selected = ui->listWidget->selectedItems();
if(selected.isEmpty())
return;
QListWidgetItem *thisOne = selected.first();
Account *acc = getAccount(thisOne);
if(acc->active) {
acc->active = false;
thisOne->setIcon(QIcon(":/icons/inactive"));
} else {
acc->active = true;
thisOne->setIcon(QIcon(":/icons/active"));
}
}
void accountmanagerdialog::writeAccounts()
{
QSettings settings;
settings.beginWriteArray("accounts");
settings.remove("");
int numItems = ui->listWidget->count();
for(int i=0;i<numItems;i++) {
settings.setArrayIndex(i);
Account *acc = getAccount(ui->listWidget->item(i));
settings.setValue("user",acc->user);
settings.setValue("password",acc->password);
settings.setValue("server",acc->server);
settings.setValue("port",acc->port);
settings.setValue("type",acc->type);
settings.setValue("active",acc->active);
}
settings.endArray();
}
void
TestRecurrentTransaction::testGetAccount() {
QFETCH(QString, name);
QFETCH(double, initialAmount);
QFETCH(double, amount);
QFETCH(QString, memo);
QFETCH(QString, color);
// create the category and store it
auto account = std::make_shared<PublicAccount>(name, amount, memo, color);
account->initialAmount = initialAmount;
auto category = std::make_shared<com::chancho::Category>("Test category", com::chancho::Category::Type::EXPENSE);
auto transactionPtr = std::make_shared<com::chancho::Transaction>(account, .50, category);
auto recurrentPtr = std::make_shared<com::chancho::RecurrentTransaction>(transactionPtr,
std::make_shared<com::chancho::RecurrentTransaction::Recurrence>());
auto qmlTransaction = std::make_shared<com::chancho::tests::PublicRecurrentTransaction>(recurrentPtr);
QCOMPARE(account->name, qmlTransaction->getAccount());
}
void SyncWindow::on_buttonBox_accepted()
{
bool allConflictsResolved = true;
for( int row = 0; row < ui->tableConflict->rowCount(); row++ ) {
QComboBox *combo = (QComboBox*)ui->tableConflict->cellWidget(row,4);
if( combo->currentIndex() == 0 ) {
allConflictsResolved = false;
continue; // This conflict has not been resolved
}
getAccount(ui->tableConflict->takeItem(row,0)->text())->
processFileConflict(ui->tableConflict->takeItem(row,1)->text(),
combo->currentText());
}
if( allConflictsResolved) {
ui->conflict->setEnabled(false);
mConflictsExist = false;
updateStatus();
}
ui->stackedWidget->setCurrentIndex(0);
}
int
Accounts::getIndex(QObject* account) {
auto qmlAcc = qobject_cast<qml::Account*>(account);
if (qmlAcc == nullptr) {
return -1;
}
auto accs = _book->accounts();
if (_book->isError()) {
LOG(INFO) << "Error when getting data from the db" << _book->lastError().toStdString();
return -1;
}
if (accs.count() > 0 ){
for(int index=0; index < accs.count(); index++) {
if (accs.at(index) == qmlAcc->getAccount()) {
return index;
}
}
}
return -1;
}
int main(int argc, char *argv[])
{
std::string procName = "CreateOTO";
if (argc == 1)
{
printHelp(procName);
return -1;
}
LoginParams *loginParams = new LoginParams(argc, argv);
SampleParams *sampleParams = new SampleParams(argc, argv);
printSampleParams(procName, loginParams, sampleParams);
if (!checkObligatoryParams(loginParams, sampleParams))
return -1;
IO2GSession *session = CO2GTransport::createSession();
session->useTableManager(Yes, 0);
SessionStatusListener *sessionListener = new SessionStatusListener(session, false,
loginParams->getSessionID(),
loginParams->getPin());
session->subscribeSessionStatus(sessionListener);
bool bConnected = login(session, sessionListener, loginParams);
bool bWasError = false;
if (bConnected)
{
bool bIsAccountEmpty = !sampleParams->getAccount() || strlen(sampleParams->getAccount()) == 0;
ResponseListener *responseListener = new ResponseListener();
TableListener *tableListener = new TableListener(responseListener);
session->subscribeResponse(responseListener);
O2G2Ptr<IO2GTableManager> tableManager = session->getTableManager();
O2GTableManagerStatus managerStatus = tableManager->getStatus();
while (managerStatus == TablesLoading)
{
Sleep(50);
managerStatus = tableManager->getStatus();
}
if (managerStatus == TablesLoadFailed)
{
std::cout << "Cannot refresh all tables of table manager" << std::endl;
}
O2G2Ptr<IO2GAccountRow> account = getAccount(tableManager, sampleParams->getAccount());
if (account)
{
if (bIsAccountEmpty)
{
sampleParams->setAccount(account->getAccountID());
std::cout << "Account: " << sampleParams->getAccount() << std::endl;
}
O2G2Ptr<IO2GOfferRow> offer = getOffer(tableManager, sampleParams->getInstrument());
if (offer)
{
O2G2Ptr<IO2GLoginRules> loginRules = session->getLoginRules();
if (loginRules)
{
O2G2Ptr<IO2GTradingSettingsProvider> tradingSettingsProvider = loginRules->getTradingSettingsProvider();
int iBaseUnitSize = tradingSettingsProvider->getBaseUnitSize(sampleParams->getInstrument(), account);
int iAmount = iBaseUnitSize * sampleParams->getLots();
// For the purpose of this example we will place primary order 30 pips below the current market price
// and our secondary order 15 pips below the current market price
double dRatePrimary = offer->getAsk() - 30.0 * offer->getPointSize();
double dRateSecondary = offer->getAsk() - 15.0 * offer->getPointSize();
O2G2Ptr<IO2GRequest> request = createOTORequest(session, offer->getOfferID(), account->getAccountID(), iAmount, dRatePrimary, dRateSecondary);
if (request)
{
tableListener->subscribeEvents(tableManager);
std::vector<std::string> requestIDs(request->getChildrenCount());
for (int i=0; i<request->getChildrenCount(); ++i)
{
requestIDs[i] = request->getChildRequest(i)->getRequestID();
}
responseListener->setRequestIDs(requestIDs);
tableListener->setRequestIDs(requestIDs);
session->sendRequest(request);
if (responseListener->waitEvents())
{
std::cout << "Done!" << std::endl;
}
else
{
std::cout << "Response waiting timeout expired" << std::endl;
bWasError = true;
}
tableListener->unsubscribeEvents(tableManager);
tableListener->release();
}
else
{
std::cout << "Cannot create request" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "Cannot get login rules" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "The instrument '" << sampleParams->getInstrument() << "' is not valid" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "No valid accounts" << std::endl;
bWasError = true;
}
session->unsubscribeResponse(responseListener);
responseListener->release();
logout(session, sessionListener);
}
else
{
bWasError = true;
}
session->unsubscribeSessionStatus(sessionListener);
sessionListener->release();
session->release();
if (bWasError)
return -1;
return 0;
}
int main(int argc, char *argv[])
{
std::string procName = "PrintTable";
if (argc == 1)
{
printHelp(procName);
return -1;
}
bool bWasError = false;
LoginParams *loginParams = new LoginParams(argc, argv);
SampleParams *sampleParams = new SampleParams(argc, argv);
printSampleParams(procName, loginParams, sampleParams);
if (!checkObligatoryParams(loginParams, sampleParams))
return -1;
IO2GSession *session = CO2GTransport::createSession();
session->useTableManager(Yes, 0);
SessionStatusListener *sessionListener = new SessionStatusListener(session, true,
loginParams->getSessionID(),
loginParams->getPin());
session->subscribeSessionStatus(sessionListener);
bool bConnected = login(session, sessionListener, loginParams);
if (bConnected)
{
bool bIsAccountEmpty = !sampleParams->getAccount() || strlen(sampleParams->getAccount()) == 0;
O2G2Ptr<IO2GTableManager> tableManager = session->getTableManager();
O2GTableManagerStatus managerStatus = tableManager->getStatus();
while (managerStatus == TablesLoading)
{
Sleep(50);
managerStatus = tableManager->getStatus();
}
if (managerStatus == TablesLoadFailed)
{
std::cout << "Cannot refresh all tables of table manager" << std::endl;
}
O2G2Ptr<IO2GAccountRow> account = getAccount(tableManager, sampleParams->getAccount());
if (account)
{
if (bIsAccountEmpty)
{
sampleParams->setAccount(account->getAccountID());
std::cout << "Account: " << sampleParams->getAccount() << std::endl;
}
}
else
{
std::cout << "No valid accounts" << std::endl;
bWasError = true;
}
printOrders(tableManager, sampleParams->getAccount());
std::cout << "Done!" << std::endl;
logout(session, sessionListener);
}
else
{
bWasError = true;
}
session->unsubscribeSessionStatus(sessionListener);
sessionListener->release();
session->release();
if (bWasError)
return -1;
return 0;
}
int main(int argc, char *argv[]){
char user[100];
char password[100];
char transaction[2048];
int auth;
int i;
if(argc!=2 && argc!=4){
printf("account password (to setup/report on your account)\n");
printf("account password amount targetAccount (to transfer)\n");
return 0;
}
strncpy(user,getenv("USER"),100); // determine who is running this
/* for auditing purposes */
transaction[0]='\0';
strncat(transaction,user,2048);
strncat(transaction,": ",2048);
for(i=1;i<argc;i++){
strncat(transaction,argv[i],2048);
strncat(transaction," ",2048);
}
strncpy(password,argv[1],99);
password[99]='\0';
auth=authenticate(user, password);
if(argc==2){
if(auth==2){
addUser(user, password);
printf("Your account has:\n");
report(user);
} else if(auth==1){
printf("Your account has:\n");
report(user);
} else {
printf("You have not been authenticated\n");
}
} else if(argc==4){ // perform a transfer to another account
if(auth==1){
int fromAmount, amount, toAmount;
//ISSUE 6: Possible unsafe (negative) amount input
amount=atoi(argv[2]);
fromAmount=getAccount(user);
toAmount=getAccount(argv[3]);
if(toAmount==-1){
printf("account %s does not exist\n",argv[3]);
} else if(fromAmount-amount>0){
printf("Your account had:\n");
report(user);
fromAmount=fromAmount-amount;
//ISSUE 5: Integer Overflow
toAmount=toAmount+amount;
setAccount(user,fromAmount);
setAccount(argv[3],toAmount);
printf("Your account now has:\n");
report(user);
} else {
printf("You do not have sufficient credits.\n");
}
} else {
printf("You have not been authenticated\n");
}
}
/* in any case, log the attempt */
logTransaction(transaction);
return 0;
}
// debit an amount from Account with specified account number
void BankDatabase::debit(int userAccountNumber, double amount)
{
Account* const userAccountPtr = getAccount(userAccountNumber);
userAccountPtr->debit(amount);
}
// return total balance of Account with specified account number
double BankDatabase::getTotalBalance(int userAccountNumber)
{
Account* const userAccountPtr = getAccount(userAccountNumber);
return userAccountPtr->getTotalBalance();
}
// credit an amount to Account with specified account number
void BankDatabase::credit( int userAccountNumber, double amount )
{
Account * const userAccountPtr = getAccount( userAccountNumber );
userAccountPtr->credit( amount );
} // end function credit
int main(int argc, char *argv[])
{
std::string procName = "NetStopLimit";
if (argc == 1)
{
printHelp(procName);
return -1;
}
LoginParams *loginParams = new LoginParams(argc, argv);
SampleParams *sampleParams = new SampleParams(argc, argv);
printSampleParams(procName, loginParams, sampleParams);
if (!checkObligatoryParams(loginParams, sampleParams))
return -1;
IO2GSession *session = CO2GTransport::createSession();
session->useTableManager(Yes, 0);
SessionStatusListener *sessionListener = new SessionStatusListener(session, false,
loginParams->getSessionID(),
loginParams->getPin());
session->subscribeSessionStatus(sessionListener);
bool bConnected = login(session, sessionListener, loginParams);
bool bWasError = false;
if (bConnected)
{
bool bIsAccountEmpty = !sampleParams->getAccount() || strlen(sampleParams->getAccount()) == 0;
ResponseListener *responseListener = new ResponseListener();
TableListener *tableListener = new TableListener(responseListener);
session->subscribeResponse(responseListener);
O2G2Ptr<IO2GTableManager> tableManager = session->getTableManager();
O2GTableManagerStatus managerStatus = tableManager->getStatus();
while (managerStatus == TablesLoading)
{
Sleep(50);
managerStatus = tableManager->getStatus();
}
if (managerStatus == TablesLoadFailed)
{
std::cout << "Cannot refresh all tables of table manager" << std::endl;
}
O2G2Ptr<IO2GAccountRow> account = getAccount(tableManager, sampleParams->getAccount());
if (account)
{
if (bIsAccountEmpty)
{
sampleParams->setAccount(account->getAccountID());
std::cout << "Account: " << sampleParams->getAccount() << std::endl;
}
O2G2Ptr<IO2GOfferRow> offer = getOffer(tableManager, sampleParams->getInstrument());
if (offer)
{
O2G2Ptr<IO2GTradeRow> trade = getTrade(tableManager, sampleParams->getAccount(), offer->getOfferID());
if (trade)
{
const char *sBuySell = strcmp(trade->getBuySell(), O2G2::Buy) == 0 ? O2G2::Sell : O2G2::Buy;
O2G2Ptr<IO2GRequest> requestStop = createNetEntryOrderRequest(session, offer->getOfferID(),
account->getAccountID(), sampleParams->getRateStop(), sBuySell, O2G2::Orders::StopEntry);
if (requestStop)
{
tableListener->subscribeEvents(tableManager);
responseListener->setRequestID(requestStop->getRequestID());
tableListener->setRequestID(requestStop->getRequestID());
session->sendRequest(requestStop);
if (responseListener->waitEvents())
{
O2G2Ptr<IO2GRequest> requestLimit = createNetEntryOrderRequest(session, offer->getOfferID(),
account->getAccountID(), sampleParams->getRateLimit(), sBuySell, O2G2::Orders::LimitEntry);
if (requestLimit)
{
responseListener->setRequestID(requestLimit->getRequestID());
tableListener->setRequestID(requestLimit->getRequestID());
session->sendRequest(requestLimit);
if (responseListener->waitEvents())
{
std::cout << "Done!" << std::endl;
}
else
{
std::cout << "Response waiting timeout expired" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "Cannot create request" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "Response waiting timeout expired" << std::endl;
bWasError = true;
}
tableListener->unsubscribeEvents(tableManager);
tableListener->release();
}
else
{
std::cout << "Cannot create request" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "There are no opened positions for instrument '" <<
sampleParams->getInstrument() << "'" << std::endl;
}
}
else
{
std::cout << "The instrument '" << sampleParams->getInstrument() <<
"' is not valid" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "No valid accounts" << std::endl;
bWasError = true;
}
session->unsubscribeResponse(responseListener);
responseListener->release();
logout(session, sessionListener);
}
else
{
bWasError = true;
}
session->unsubscribeSessionStatus(sessionListener);
sessionListener->release();
session->release();
if (bWasError)
return -1;
return 0;
}
void BankDatabase::debit(int accountNumber, int money){
getAccount(accountNumber)->debit(money);
}
int main(int argc, char *argv[])
{
std::string procName = "JoinNewGroup";
if (argc == 1)
{
printHelp(procName);
return -1;
}
bool bWasError = false;
LoginParams *loginParams = new LoginParams(argc, argv);
SampleParams *sampleParams = new SampleParams(argc, argv);
printSampleParams(procName, loginParams, sampleParams);
if (!checkObligatoryParams(loginParams, sampleParams))
return -1;
IO2GSession *session = CO2GTransport::createSession();
int iContingencyGroupType = 1; // OCO group
SessionStatusListener *sessionListener = new SessionStatusListener(session, true,
loginParams->getSessionID(),
loginParams->getPin());
session->subscribeSessionStatus(sessionListener);
bool bConnected = login(session, sessionListener, loginParams);
if (bConnected)
{
bool bIsAccountEmpty = !sampleParams->getAccount() || strlen(sampleParams->getAccount()) == 0;
O2G2Ptr<IO2GAccountRow> account = getAccount(session, sampleParams->getAccount());
ResponseListener *responseListener = new ResponseListener(session);
session->subscribeResponse(responseListener);
if (account)
{
if (bIsAccountEmpty)
{
sampleParams->setAccount(account->getAccountID());
std::cout << "Account: " << sampleParams->getAccount() << std::endl;
}
std::vector<std::string> orderIDs(2);
orderIDs[0] = sampleParams->getPrimaryID();
orderIDs[1] = sampleParams->getSecondaryID();
for (size_t i=0; i < orderIDs.size(); ++i)
{
if (!isOrderExists(session, sampleParams->getAccount(), orderIDs[i].c_str(), responseListener))
{
std::cout << "Order '" << orderIDs[i] << "' does not exist" << std::endl;
bWasError = true;
}
}
if (!bWasError)
{
O2G2Ptr<IO2GRequest> request = joinToNewGroupRequest(session, sampleParams->getAccount(),
orderIDs, iContingencyGroupType);
if (request)
{
responseListener->setRequestID(request->getRequestID());
responseListener->setOrderIDs(orderIDs);
session->sendRequest(request);
if (responseListener->waitEvents())
{
std::cout << "Done!" << std::endl;
}
else
{
std::cout << "Response waiting timeout expired" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "Cannot create request" << std::endl;
bWasError = true;
}
}
}
else
{
std::cout << "No valid accounts" << std::endl;
bWasError = true;
}
session->unsubscribeResponse(responseListener);
responseListener->release();
logout(session, sessionListener);
}
else
{
bWasError = true;
}
session->unsubscribeSessionStatus(sessionListener);
sessionListener->release();
session->release();
if (bWasError)
return -1;
return 0;
}
int main(int argc, char *argv[])
{
std::string procName = "GetLastOrderUpdate";
if (argc == 1)
{
printHelp(procName);
return -1;
}
bool bWasError = false;
LoginParams *loginParams = new LoginParams(argc, argv);
SampleParams *sampleParams = new SampleParams(argc, argv);
printSampleParams(procName, loginParams, sampleParams);
if (!checkObligatoryParams(loginParams, sampleParams))
{
delete loginParams;
delete sampleParams;
return -1;
}
IO2GSession *session = CO2GTransport::createSession();
SessionStatusListener *sessionListener = new SessionStatusListener(session, true,
loginParams->getSessionID(),
loginParams->getPin());
session->subscribeSessionStatus(sessionListener);
bool bConnected = login(session, sessionListener, loginParams);
if (bConnected)
{
bool bIsAccountEmpty = !sampleParams->getAccount() || strlen(sampleParams->getAccount()) == 0;
O2G2Ptr<IO2GAccountRow> account = getAccount(session, sampleParams->getAccount());
ResponseListener *responseListener = new ResponseListener(session);
session->subscribeResponse(responseListener);
if (account)
{
if (bIsAccountEmpty)
{
sampleParams->setAccount(account->getAccountID());
std::cout << "Account: " << sampleParams->getAccount() << std::endl;
}
O2G2Ptr<IO2GOfferRow> offer = getOffer(session, sampleParams->getInstrument());
if (offer)
{
O2G2Ptr<IO2GLoginRules> loginRules = session->getLoginRules();
if (loginRules)
{
O2G2Ptr<IO2GTradingSettingsProvider> tradingSettingsProvider = loginRules->getTradingSettingsProvider();
int iBaseUnitSize = tradingSettingsProvider->getBaseUnitSize(sampleParams->getInstrument(), account);
int iAmount = iBaseUnitSize * sampleParams->getLots();
O2G2Ptr<IO2GRequest> request = createTrueMarketOrderRequest(session, offer->getOfferID(), account->getAccountID(), iAmount, sampleParams->getBuySell());
if (request)
{
responseListener->setRequestID(request->getRequestID());
session->sendRequest(request);
if (responseListener->waitEvents())
{
std::string sOrderID = responseListener->getOrderID();
if (!sOrderID.empty())
{
O2G2Ptr<IO2GRequest> updateRequest = getLastOrderUpdateRequest(session, sOrderID.c_str(), account->getAccountName());
if (updateRequest)
{
responseListener->setRequestID(updateRequest->getRequestID());
session->sendRequest(updateRequest);
if (responseListener->waitEvents())
{
O2G2Ptr<IO2GResponse> response = responseListener->getResponse();
if (response && response->getType() == GetLastOrderUpdate)
{
O2G2Ptr<IO2GResponseReaderFactory> readerFactory = session->getResponseReaderFactory();
if (readerFactory)
{
O2G2Ptr<IO2GLastOrderUpdateResponseReader> reader = readerFactory->createLastOrderUpdateResponseReader(response);
char sTime[20];
formatDate(reader->getOrder()->getStatusTime(), sTime);
std::cout << "Last order update: UpdateType='" << reader->getUpdateType() << "', "
<< "OrderID='" << reader->getOrder()->getOrderID() << "', "
<< "Status='" << reader->getOrder()->getStatus() << "', "
<< "StatusTime='" << sTime << "'"
<< std::endl;
}
}
std::cout << "Done!" << std::endl;
}
else
{
std::cout << "Response waiting timeout expired" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "Cannot create request" << std::endl;
bWasError = true;
}
}
}
else
{
std::cout << "Response waiting timeout expired" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "Cannot create request" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "Cannot get login rules" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "The instrument '" << sampleParams->getInstrument() << "' is not valid" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "No valid accounts" << std::endl;
bWasError = true;
}
session->unsubscribeResponse(responseListener);
responseListener->release();
logout(session, sessionListener);
}
else
{
bWasError = true;
}
session->unsubscribeSessionStatus(sessionListener);
sessionListener->release();
session->release();
delete loginParams;
delete sampleParams;
if (bWasError)
return -1;
return 0;
}
int main(int argc, char* argv[])
{
std::string procName = "CloseAllPositionsByInstrument";
if (argc == 1)
{
printHelp(procName);
return -1;
}
LoginParams *loginParams = new LoginParams(argc, argv);
SampleParams *sampleParams = new SampleParams(argc, argv);
printSampleParams(procName, loginParams, sampleParams);
if (!checkObligatoryParams(loginParams, sampleParams))
return -1;
IO2GSession *session = CO2GTransport::createSession();
SessionStatusListener *sessionListener = new SessionStatusListener(session, false,
loginParams->getSessionID(),
loginParams->getPin());
session->subscribeSessionStatus(sessionListener);
bool bConnected = login(session, sessionListener, loginParams);
bool bWasError = false;
if (bConnected)
{
bool bIsAccountEmpty = !sampleParams->getAccount() || strlen(sampleParams->getAccount()) == 0;
O2G2Ptr<IO2GAccountRow> account = getAccount(session, sampleParams->getAccount());
ResponseListener *responseListener = new ResponseListener(session);
session->subscribeResponse(responseListener);
if (account)
{
if (bIsAccountEmpty)
{
sampleParams->setAccount(account->getAccountID());
std::cout << "Account: " << sampleParams->getAccount() << std::endl;
}
O2G2Ptr<IO2GOfferRow> offer = getOffer(session, sampleParams->getInstrument());
if (offer)
{
CloseOrderData closeOrdersData;
if (getCloseOrdersData(session, responseListener, sampleParams->getAccount(), offer->getOfferID(), closeOrdersData))
{
O2G2Ptr<IO2GRequest> request = createCloseMarketNettingOrderRequest(session, &closeOrdersData);
if (request)
{
std::vector<std::string> requestIDs(request->getChildrenCount());
for (int i = 0; i < request->getChildrenCount(); ++i)
{
IO2GRequest *requestChild = request->getChildRequest(i);
requestIDs[i] = requestChild->getRequestID();
requestChild->release();
}
responseListener->setRequestIDs(requestIDs);
session->sendRequest(request);
if (responseListener->waitEvents())
{
Sleep(1000); // Wait for the balance update
std::cout << "Done!" << std::endl;
}
else
{
std::cout << "Response waiting timeout expired" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "Cannot create request" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "There are no opened positions for instrument '" <<
sampleParams->getInstrument() << "'" << std::endl;
}
}
else
{
std::cout << "The instrument '" << sampleParams->getInstrument() << "' is not valid" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "No valid accounts" << std::endl;
bWasError = true;
}
session->unsubscribeResponse(responseListener);
responseListener->release();
logout(session, sessionListener);
}
else
{
bWasError = true;
}
session->unsubscribeSessionStatus(sessionListener);
sessionListener->release();
session->release();
if (bWasError)
return -1;
return 0;
}
int main(int argc, char *argv[])
{
std::string procName = "OpenPosition";
if (argc == 1)
{
printHelp(procName);
return -1;
}
LoginParams *loginParams = new LoginParams(argc, argv);
SampleParams *sampleParams = new SampleParams(argc, argv);
printSampleParams(procName, loginParams, sampleParams);
if (!checkObligatoryParams(loginParams, sampleParams))
return -1;
IO2GSession *session = CO2GTransport::createSession();
session->useTableManager(Yes, 0);
SessionStatusListener *sessionListener = new SessionStatusListener(session, false,
loginParams->getSessionID(),
loginParams->getPin());
session->subscribeSessionStatus(sessionListener);
bool bConnected = login(session, sessionListener, loginParams);
bool bWasError = false;
if (bConnected)
{
bool bIsAccountEmpty = !sampleParams->getAccount() || strlen(sampleParams->getAccount()) == 0;
ResponseListener *responseListener = new ResponseListener();
TableListener *tableListener = new TableListener(responseListener);
session->subscribeResponse(responseListener);
O2G2Ptr<IO2GTableManager> tableManager = session->getTableManager();
O2GTableManagerStatus managerStatus = tableManager->getStatus();
while (managerStatus == TablesLoading)
{
Sleep(50);
managerStatus = tableManager->getStatus();
}
if (managerStatus == TablesLoadFailed)
{
std::cout << "Cannot refresh all tables of table manager" << std::endl;
}
O2G2Ptr<IO2GAccountRow> account = getAccount(tableManager, sampleParams->getAccount());
if (account && strcmp(account->getMaintenanceType(), "0") != 0) // not netting account
{
if (bIsAccountEmpty)
{
sampleParams->setAccount(account->getAccountID());
std::cout << "Account: " << sampleParams->getAccount() << std::endl;
}
O2G2Ptr<IO2GOfferRow> offer = getOffer(tableManager, sampleParams->getInstrument());
if (offer)
{
O2G2Ptr<IO2GLoginRules> loginRules = session->getLoginRules();
if (loginRules)
{
O2G2Ptr<IO2GTradingSettingsProvider> tradingSettingsProvider = loginRules->getTradingSettingsProvider();
int iBaseUnitSize = tradingSettingsProvider->getBaseUnitSize(sampleParams->getInstrument(), account);
int iAmount = iBaseUnitSize * sampleParams->getLots();
O2G2Ptr<IO2GRequest> request = createTrueMarketOrderRequest(session, offer->getOfferID(), account->getAccountID(), iAmount, sampleParams->getBuySell());
if (request)
{
tableListener->subscribeEvents(tableManager);
responseListener->setRequestID(request->getRequestID());
tableListener->setRequestID(request->getRequestID());
session->sendRequest(request);
if (responseListener->waitEvents())
{
Sleep(1000); // Wait for the balance update
std::cout << "Done!" << std::endl;
}
else
{
std::cout << "Response waiting timeout expired" << std::endl;
bWasError = true;
}
tableListener->unsubscribeEvents(tableManager);
tableListener->release();
}
else
{
std::cout << "Cannot create request" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "Cannot get login rules" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "The instrument '" << sampleParams->getInstrument() << "' is not valid" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "No valid accounts" << std::endl;
bWasError = true;
}
session->unsubscribeResponse(responseListener);
responseListener->release();
logout(session, sessionListener);
}
else
{
bWasError = true;
}
session->unsubscribeSessionStatus(sessionListener);
sessionListener->release();
session->release();
if (bWasError)
return -1;
return 0;
}
int main(int argc, char *argv[])
{
std::string procName = "CreateEntry";
if (argc == 1)
{
printHelp(procName);
return -1;
}
bool bWasError = false;
LoginParams *loginParams = new LoginParams(argc, argv);
SampleParams *sampleParams = new SampleParams(argc, argv);
printSampleParams(procName, loginParams, sampleParams);
if (!checkObligatoryParams(loginParams, sampleParams))
return -1;
IO2GSession *session = CO2GTransport::createSession();
SessionStatusListener *sessionListener = new SessionStatusListener(session, true,
loginParams->getSessionID(),
loginParams->getPin());
session->subscribeSessionStatus(sessionListener);
bool bConnected = login(session, sessionListener, loginParams);
if (bConnected)
{
bool bIsAccountEmpty = !sampleParams->getAccount() || strlen(sampleParams->getAccount()) == 0;
O2G2Ptr<IO2GAccountRow> account = getAccount(session, sampleParams->getAccount());
ResponseListener *responseListener = new ResponseListener(session);
session->subscribeResponse(responseListener);
if (account)
{
if (bIsAccountEmpty)
{
sampleParams->setAccount(account->getAccountID());
std::cout << "Account: " << sampleParams->getAccount() << std::endl;
}
O2G2Ptr<IO2GOfferRow> offer = getOffer(session, sampleParams->getInstrument());
if (offer)
{
O2G2Ptr<IO2GLoginRules> loginRules = session->getLoginRules();
if (loginRules)
{
O2G2Ptr<IO2GTradingSettingsProvider> tradingSettingsProvider = loginRules->getTradingSettingsProvider();
int iBaseUnitSize = tradingSettingsProvider->getBaseUnitSize(sampleParams->getInstrument(), account);
int iAmount = iBaseUnitSize * sampleParams->getLots();
int iCondDistEntryLimit = tradingSettingsProvider->getCondDistEntryLimit(sampleParams->getInstrument());
int iCondDistEntryStop = tradingSettingsProvider->getCondDistEntryStop(sampleParams->getInstrument());
std::string sOrderType = getEntryOrderType(offer->getBid(), offer->getAsk(), sampleParams->getRate(),
sampleParams->getBuySell(), offer->getPointSize(), iCondDistEntryLimit, iCondDistEntryStop);
O2G2Ptr<IO2GRequest> request = createEntryOrderRequest(session, offer->getOfferID(), account->getAccountID(), iAmount,
sampleParams->getRate(), sampleParams->getBuySell(), sOrderType.c_str(), sampleParams->getExpDate());
if (request)
{
responseListener->setRequestID(request->getRequestID());
session->sendRequest(request);
if (responseListener->waitEvents())
{
std::cout << "Done!" << std::endl;
}
else
{
std::cout << "Response waiting timeout expired" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "Cannot create request" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "Cannot get login rules" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "The instrument '" << sampleParams->getInstrument() << "' is not valid" << std::endl;
bWasError = true;
}
}
else
{
std::cout << "No valid accounts" << std::endl;
bWasError = true;
}
session->unsubscribeResponse(responseListener);
responseListener->release();
logout(session, sessionListener);
}
else
{
bWasError = true;
}
session->unsubscribeSessionStatus(sessionListener);
sessionListener->release();
session->release();
if (bWasError)
return -1;
return 0;
}
void BankDatabase::credit(int accountNumber, int money){
getAccount(accountNumber)->credit(money);
}
QByteArray KMoneyThingFile::dump()
{
QByteArray output;
QDataStream stream(output, IO_WriteOnly);
stream << (QString) "KMoneyThing Document" << (QString) "pre1_draft";
stream << (QString) "<name>" << mName << (QString) "</name>";
stream << (QString) "<locale>" << mLocale << (QString) "</locale>";
for (Q_UINT32 aI = 0; aI < accounts(); aI++)
{
KMoneyThingAccount* account = getAccount(aI);
stream << (QString) "<account>";
stream << (QString) "<type>" << account->type() << (QString) "</type>";
stream << (QString) "<name>" << account->name() << (QString) "</name>";
stream << (QString) "<description>" << account->description() << (QString) "</description>";
stream << (QString) "<accountNumber>" << account->accountNumber() << (QString) "</accountNumber>";
stream << (QString) "<institution>" << account->institution() << (QString) "</institution>";
stream << (QString) "<locale>" << account->locale() << (QString) "</locale>";
stream << (QString) "<balance>" << account->balance() << (QString) "</balance>";
stream << (QString) "<startingBalance>" << account->startingBalance() << (QString) "</startingBalance>";
for (Q_UINT32 tI = 0; tI < account->transactions(); tI++)
{
KMoneyThingTransaction* transaction = account->getTransaction(tI);
stream << (QString) "<transaction>";
stream << (QString) "<name>" << transaction->name() << (QString) "</name>";
stream << (QString) "<type>" << transaction->type() << (QString) "</type>";
stream << (QString) "<category>" << transaction->category() << (QString) "</category>";
stream << (QString) "<payee>" << transaction->payee() << (QString) "</payee>";
stream << (QString) "<state>" << transaction->state() << (QString) "</state>";
stream << (QString) "<statement>" << transaction->statementId() << (QString) "</statement>";
stream << (QString) "<split>" << transaction->split() << (QString) "</split>";
stream << (QString) "<foreign>" << transaction->foreign() << (QString) "</foreign>";
stream << (QString) "<exRate>" << transaction->exchangeRate() << (QString) "</exRate>";
stream << (QString) "<accCurIn>" << transaction->accountCurrencyIn() << (QString) "</accCurIn>";
stream << (QString) "<accCurOut>" << transaction->accountCurrencyOut() << (QString) "</accCurOut>";
stream << (QString) "<trCurIn>" << transaction->transactionCurrencyIn() << (QString) "</trCurIn>";
stream << (QString) "<trCurOut>" << transaction->transactionCurrencyOut() << (QString) "</trCurOut>";
stream << (QString) "<trCurName>" << transaction->transactionCurrencyName() << (QString) "</trCurName>";
for (Q_UINT32 stI = 0; stI < transaction->subTransactions(); stI++)
{
KMoneyThingSubTransaction* subTransaction = transaction->getSubTransaction(stI);
stream << (QString) "<subTransaction>";
stream << (QString) "<name>" << subTransaction->name() << (QString) "</name>";
stream << (QString) "<category>" << subTransaction->category() << (QString) "</category>";
stream << (QString) "<trCurIn>" << subTransaction->transactionCurrencyIn() << (QString) "</trCurIn>";
stream << (QString) "<trCurOut>" << subTransaction->transactionCurrencyOut() << (QString) "</trCurOut>";
stream << (QString) "</subTransaction>";
}
for (Q_UINT32 rI = 0; rI < transaction->references(); rI++)
{
KMoneyThingTransaction::Reference* reference = transaction->getReference(rI);
stream << (QString) "<reference>";
stream << (QString) "<refAccount>" << reference->accountName << (QString) "</refAccount>";
stream << (QString) "<refTransaction>" << reference->transactionID << (QString) "</refTransaction>";
stream << (QString) "</reference>";
}
stream << (QString) "</transaction>";
}
stream << (QString) "</account>";
}
for (Q_UINT32 cI = 0; cI < categories(); cI++)
stream << (QString) "<category>" << getCategory(cI) << (QString) "</category>";
for (Q_UINT32 rI = 0; rI < recurrences(); rI++)
{
KMoneyThingRecurringTransaction* transaction = getRecurrence(rI);
stream << (QString) "<recurrence>";
// If KMoneyThingTransaction is changed, copy its new code from above,
// overwriting from ***HERE*** ...
stream << (QString) "<name>" << transaction->name() << (QString) "</name>";
stream << (QString) "<type>" << transaction->type() << (QString) "</type>";
stream << (QString) "<category>" << transaction->category() << (QString) "</category>";
stream << (QString) "<state>" << transaction->state() << (QString) "</state>";
stream << (QString) "<statement>" << transaction->statementId() << (QString) "</statement>";
stream << (QString) "<split>" << transaction->split() << (QString) "</split>";
stream << (QString) "<foreign>" << transaction->foreign() << (QString) "</foreign>";
stream << (QString) "<exRate>" << transaction->exchangeRate() << (QString) "</exRate>";
stream << (QString) "<accCurIn>" << transaction->accountCurrencyIn() << (QString) "</accCurIn>";
stream << (QString) "<accCurOut>" << transaction->accountCurrencyOut() << (QString) "</accCurOut>";
stream << (QString) "<trCurIn>" << transaction->transactionCurrencyIn() << (QString) "</trCurIn>";
stream << (QString) "<trCurOut>" << transaction->transactionCurrencyOut() << (QString) "</trCurOut>";
stream << (QString) "<trCurName>" << transaction->transactionCurrencyName() << (QString) "</trCurName>";
for (Q_UINT32 stI = 0; stI < transaction->subTransactions(); stI++)
{
KMoneyThingSubTransaction* subTransaction = transaction->getSubTransaction(stI);
stream << (QString) "<subTransaction>";
stream << (QString) "<name>" << subTransaction->name() << (QString) "</name>";
stream << (QString) "<category>" << subTransaction->category() << (QString) "</category>";
stream << (QString) "<trCurIn>" << subTransaction->transactionCurrencyIn() << (QString) "</trCurIn>";
stream << (QString) "<trCurOut>" << subTransaction->transactionCurrencyOut() << (QString) "</trCurOut>";
stream << (QString) "</subTransaction>";
}
for (Q_UINT32 rI = 0; rI < transaction->references(); rI++)
{
KMoneyThingTransaction::Reference* reference = transaction->getReference(rI);
stream << (QString) "<reference>";
stream << (QString) "<refAccount>" << reference->accountName << (QString) "</refAccount>";
stream << (QString) "<refTransaction>" << reference->transactionID << (QString) "</refTransaction>";
stream << (QString) "</reference>";
}
// ... to ***HERE***
stream << (QString) "<recurrency>" << transaction->recurrence() << (QString) "</recurrency>";
stream << (QString) "<xDays>" << transaction->xDays() << (QString) "</xDays>";
stream << (QString) "<firstDate>" << transaction->firstDate() << (QString) "</firstDate>";
stream << (QString) "<daysOn>";
for (char i = 0; i < 7; i++)
stream << transaction->isDayOn(i);
stream << (QString) "</daysOn>";
stream << (QString) "</recurrence>";
}
stream.device()->close();
return qCompress(output);
}
int BankDatabase::getBalance(int accountNumber){
return getAccount(accountNumber)->getBalance();
}
