bool
ObjectCache::findAccount(Id account_id, Account& account)
{
Account* object = findAccount(account_id);
if (object == NULL) return false;
account = *object;
return true;
}
void Account::setName(const QString& name) {
if (findAccount() == this) {
removeId();
}
m_name = name;
insertId();
changed();
}
int feeList(List* list, unsigned int acc_num, int amount) {
if (list == NULL) return ERROR;
Node* node = findAccount(list, acc_num);
if (node == NULL) {
return NO_ACCOUNT;
} else {
return feeNode(node, amount);
}
}
int depositList(List* list, unsigned int acc_num, int amount) {
if (list == NULL) return ERROR;
Node* node = findAccount(list, acc_num);
if (node == NULL) {
return makeAccount(list, acc_num, amount);
} else {
return depositNode(node, amount);
}
}
bool
OpenBalances::importAccount(QDomNodeList& nodes)
{
Account account;
fixed debit = 0.0;
fixed credit = 0.0;
for (uint i = 0; i < nodes.count(); ++i) {
QDomNode node = nodes.item(i);
if (node.isNull()) continue;
QDomElement e = node.toElement();
if (e.isNull()) continue;
QString tag = e.tagName();
QString text = e.text();
if (tag == "name") {
if (!findAccount(text, account))
warning("Can't find account: " + text);
} else if (tag == "number") {
if (!findAccount(text, account))
warning("Can't find account: " + text);
} else if (tag == "debit") {
debit = text.toDouble();
} else if (tag == "credit") {
credit = text.toDouble();
} else {
warning("Unknown account tag: " + tag);
}
}
if (account.id() == INVALID_ID) {
warning("Failed account import");
return false;
}
VectorRow* row = new VectorRow(_accounts->columns());
row->setValue(0, account.id());
if (debit != 0.0) row->setValue(1, debit);
if (credit != 0.0) row->setValue(2, credit);
_accounts->appendRow(row);
return true;
}
void Bank::addAccount (const std::string name, double balance, double limited)
{
OverdraftAccount * _a = new OverdraftAccount(ID, name, balance, limited);
ID++;
if (findAccount(* _a) != -1)
throw "This account already exists!";
m_vOverdruftAccounts.push_back(_a);
}
int withdrawList(List* list, unsigned int acc_num, int amount) {
if (list == NULL) return ERROR;
Node* node = findAccount(list, acc_num);
if (node != NULL) {
int res = withdrawNode(node, amount);
return res;
} else {
return NO_ACCOUNT;
}
}
void Bank::addAccount (const std::string name, double balance)
{
Account * _a = new Account(ID, name, balance);
ID++;
if (findAccount(* _a) != -1)
throw "This account already exists!";
m_vAccounts.push_back(_a);
}
void Bank::leaveAccount (Account * _a)
{
int id = findAccount (* _a);
if (id == -1)
throw "This account does not exist!";
for (int i = 0; i < m_vAccounts.size(); i++)
if (id == m_vAccounts[i]->getID())
m_vAccounts.erase(m_vAccounts.begin() + i);
delete _a;
}
Account::~Account() {
//kDebug(planDbg())<<m_name;
if (findAccount() == this) {
removeId(); // only remove myself (I may be just a working copy)
}
if (m_list)
m_list->accountDeleted(this);
while (!m_accountList.isEmpty())
delete m_accountList.takeFirst();
while (!m_costPlaces.isEmpty())
delete m_costPlaces.takeFirst();
}
int Bank::deleteAccount(const QString &ID){
QString sql;
char* err;
QByteArray ba;
if(!findAccount(ID))
return 1;
sql = "DELETE FROM accounts WHERE ID=" + ID;
ba = sql.toLatin1();
sqlite3_exec(interface, ba.data(), InitCallback, 0, &err);
sql = "DELETE FROM trades WHERE ID=" + ID;
sqlite3_exec(interface, sql.toLatin1().data(), InitCallback, 0, &err);
return 0;
}
int Bank::validate(const QString &ID, const QString &password){
if(!findAccount(ID))
return 1;
Validate_S vs;
QByteArray ba = password.toLatin1();
vs.password = ba.data();
vs.ok = 2;
QString sql = "SELECT password FROM accounts WHERE ID=" + ID;
QByteArray ba2 = sql.toLatin1();
char* err;
if(sqlite3_exec(interface, ba2.data(), ValidateCallback, &vs, &err) != SQLITE_OK){
std::cerr << err;
throw(err);
}
return vs.ok;
}
bool BankManager::deleteAccount ()
{
bool success = false;
int accountNumber = 0;
int counter = 0;
counter = findAccount ();
if ((counter < mNumberAccounts) && (mAccountsAvailablePtr[counter] == false)) // we found the account, so delete it
{
success = true;
mAccountsAvailablePtr[counter] = true;
cout << "Account deleted!" << endl;
}
return success;
}
std::shared_ptr<Account> AccountManager::enterServer(int ingameid)
{
AccountInfo info;
info.ingameid = ingameid;
info.session = clock();
info.logname = getPlayerNameFixed(info.ingameid);
auto r = accounts.insert(std::make_pair(ingameid, std::make_shared<Account>(info, datasource)));
if (r.first == accounts.end())
{
std::cout << "[AccountManager] Warning: enterServer failed.\n";
return findAccount(-1);
}
SendClientMessageToAll(0xFFFFFFFF, STR(r.first->second->getLogName() << UID(r.first->second) << "进入服务器.").c_str());
return r.first->second;
}
AccountKeys* KeyStore::addAccount(QVariantMap account) {
if (!accountUnsupportedReason(account).isEmpty())
return nullptr;
AccountKeys* accountKeys(findAccount(account["name"].toString()));
if (accountKeys == nullptr) {
accountKeys = new AccountKeys(this);
connect(accountKeys, &AccountKeys::updated, this, &KeyStore::persist);
m_accountList->append(accountKeys);
}
accountKeys->setName(account["name"].toString());
accountKeys->ownerKey()->fromAuthority(account["owner"].toMap());
accountKeys->activeKey()->fromAuthority(account["active"].toMap());
accountKeys->postingKey()->fromAuthority(account["posting"].toMap());
accountKeys->memoKey()->fromPublicKey(account["memo_key"].toString());
return accountKeys;
}
int Bank::createAccount(const QString &ID, const QString &password){
QString sql;
char* err;
QByteArray ba;
if(findAccount(ID))
return 1;
sql = "INSERT INTO accounts (ID, password, money) VALUES (";
sql = sql + ID;
sql = sql + ",";
sql = sql + password;
sql = sql + ",0)";
ba = sql.toLatin1();
if(sqlite3_exec(interface, ba.data(), InitCallback, 0, &err) != SQLITE_OK){
std::cerr << err;
throw(err);
}
else
return 0;
}
void HistoryWindow::fillContactComboBox(int index)
{
if (ui.accountComboBox->count() == 0)
return;
auto accountInfo = ui.accountComboBox->itemData(index).value<History::AccountInfo>();
ui.fromComboBox->clear();
history()->contacts(accountInfo).connect(this, [this, accountInfo] (const QVector<History::ContactInfo> &contacts) {
int index = ui.accountComboBox->currentIndex();
auto currentAccountInfo = ui.accountComboBox->itemData(index).value<History::AccountInfo>();
if (!(accountInfo == currentAccountInfo))
return;
disconnect(m_contactConnection);
Account *account = findAccount(accountInfo);
for (const History::ContactInfo &info : contacts) {
QString name = info.contact;
if (ChatUnit *unit = account ? account->getUnit(info.contact) : nullptr) {
if (unit->title() != name)
name += QStringLiteral(" - ") + unit->title();
}
ui.fromComboBox->addItem(name, QVariant::fromValue(info));
}
ui.fromComboBox->model()->sort(0);
m_contactConnection = connect(ui.fromComboBox, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
this, &HistoryWindow::fillDateTreeWidget);
int contactIndex = ui.fromComboBox->findData(QVariant::fromValue(m_unitInfo));
if (!contactIndex)
fillDateTreeWidget(0);
else
ui.fromComboBox->setCurrentIndex(contactIndex);
});
}
void HistoryWindow::fillAccountComboBox()
{
history()->accounts().connect(this, [this] (const QVector<History::AccountInfo> &accounts) {
for (const History::AccountInfo &info : accounts) {
QString name = info.account;
Icon icon(QLatin1String("im-") + info.protocol);
if (Account *account = findAccount(info)) {
if (!account->name().isEmpty())
name += QStringLiteral(" - ") + account->name();
}
ui.accountComboBox->addItem(icon, name, QVariant::fromValue(info));
}
connect(ui.accountComboBox, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
this, &HistoryWindow::fillContactComboBox);
int accountIndex = ui.accountComboBox->findData(QVariant::fromValue<History::AccountInfo>(m_unitInfo));
if (accountIndex < 0)
fillContactComboBox(0);
else
ui.accountComboBox->setCurrentIndex(accountIndex);
});
}
bool BankManager::updateAccount ()
{
bool success = false;
string name = "", dateCreated = "";
double balance = 0.0, deposit = 0.0;
int accountNumber = 0, counter = 0, option = 0;
counter = findAccount ();
if ((counter < mNumberAccounts) && (mAccountsAvailablePtr[counter] == false)) // we found the account, so delete it
{
success = true;
cout << "1. Update Name" << endl;
cout << "2. Withdraw Money" << endl;
cout << "3. Deposit Money" << endl;
cin >> option;
switch (option)
{
case 1: cout << "Enter name: ";
cin >> name;
mAccountsPtr[counter].setName (name);
break;
case 2: cout << "Enter amount to withdraw: ";
cin >> balance;
mAccountsPtr[counter].debit (balance);
break;
case 3: cout << "Enter amount to deposit: ";
cin >> deposit;
mAccountsPtr[counter].credit (deposit);
break;
default: cout << "ERROR: Invalid option!" << endl;
break;
}
}
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;
}
void HistoryWindow::on_dateTreeWidget_currentItemChanged(QTreeWidgetItem *dayItem, QTreeWidgetItem *)
{
QTreeWidgetItem *monthItem = dayItem ? dayItem->parent() : nullptr;
if (!dayItem || !monthItem)
return;
if (dayItem->data(0, Qt::UserRole).type() != QVariant::Date)
return;
if (monthItem->data(0, Qt::UserRole).type() != QVariant::Date)
return;
auto contactIndex = ui.fromComboBox->currentIndex();
auto contactInfo = ui.fromComboBox->itemData(contactIndex).value<History::ContactInfo>();
auto date = dayItem->data(0, Qt::UserRole).toDate();
QDateTime from(date, QTime(0, 0));
QDateTime to(date, QTime(23, 59, 59, 999));
int count = std::numeric_limits<int>::max();
history()->read(contactInfo, from, to, count).connect(this, [this, contactInfo, date] (const MessageList &messages) {
int contactIndex = ui.fromComboBox->currentIndex();
auto currentContactInfo = ui.fromComboBox->itemData(contactIndex).value<History::ContactInfo>();
if (!(currentContactInfo == contactInfo))
return;
QTextDocument *doc = ui.historyLog->document();
doc->setParent(0);
ui.historyLog->setDocument(0);
doc->clear();
QTextCursor cursor = QTextCursor(doc);
QTextCharFormat defaultFont = cursor.charFormat();
QTextCharFormat serviceFont = cursor.charFormat();
serviceFont.setForeground(Qt::darkGreen);
serviceFont.setFontWeight(QFont::Bold);
QTextCharFormat incomingFont = cursor.charFormat();
incomingFont.setForeground(Qt::red);
incomingFont.setFontWeight(QFont::Bold);
QTextCharFormat outgoingFont = cursor.charFormat();
outgoingFont.setForeground(Qt::blue);
outgoingFont.setFontWeight(QFont::Bold);
const QString serviceMessageTitle = tr("Service message");
const QString resultString = QStringLiteral("<span style='background: #ffff00'>\\1</span>");
cursor.beginEditBlock();
Account *account = findAccount(contactInfo);
ChatUnit *unit = findContact(contactInfo);
QString accountNickname = account ? account->name() : contactInfo.account;
QString fromNickname = unit ? unit->title() : contactInfo.contact;
int in_count = 0;
int out_count = 0;
for (const Message &message : messages) {
bool service = message.property("service", false);
QDateTime time = message.time();
bool incoming = message.isIncoming();
QString historyMessage = message.html();
QString sender = message.property("senderName", incoming ? fromNickname : accountNickname);
incoming ? in_count++ : out_count++;
if (service) {
cursor.setCharFormat(serviceFont);
cursor.insertText(serviceMessageTitle);
} else {
cursor.setCharFormat(incoming ? incomingFont : outgoingFont);
cursor.insertText(sender);
}
cursor.insertText(QStringLiteral(" (")
% time.toString(QStringLiteral("dd.MM.yyyy hh:mm:ss"))
% QStringLiteral(")"));
cursor.setCharFormat(defaultFont);
cursor.insertText(QStringLiteral("\n"));
if (m_search_word.isEmpty()) {
cursor.insertHtml(historyMessage);
cursor.insertText(QStringLiteral("\n"));
} else {
cursor.insertHtml(historyMessage.replace(m_search, resultString));
cursor.insertText(QStringLiteral("\n"));
}
}
cursor.endEditBlock();
doc->setParent(ui.historyLog);
ui.historyLog->setDocument(doc);
if (m_search_word.isEmpty())
ui.historyLog->moveCursor(QTextCursor::End);
else
ui.historyLog->find(m_search_word);
ui.historyLog->verticalScrollBar()->setValue(ui.historyLog->verticalScrollBar()->maximum());
ui.label_in->setText(tr("In: %L1").arg(in_count));
ui.label_out->setText(tr("Out: %L1").arg(out_count));
ui.label_all->setText(tr("All: %L1").arg(in_count + out_count));
});
}
static inline ChatUnit *findContact(const History::ContactInfo &info)
{
if (Account *account = findAccount(info))
return account->getUnit(info.contact);
return nullptr;
}
/**
* Processes the input from the client, given the command, argument, and state
* of the client.
*
* The 'state' is simply whether or not the client is in a session.
* -1: Client wishes to exit
* 0: Client is connected, but is not in an account session
* 1: Client is connected and is in an account session
*
*/
int process_input(char *buffer, int state, client_t **client){
int i;
char *parsed = NULL;
int len = strlen(buffer);
for(i = 0; i < len; i++){
if(buffer[i] == '\n'){
if(i == 0){
/*If it's just a newline*/
break;
}
parsed = malloc(sizeof(char)*(i+1));
strncpy(parsed, buffer, i);
parsed[i] = '\0';
break;
}
}
if(parsed == NULL){
printf("Error parsing buffer.\n");
return state;
}
printf("CLIENT> %s\n", parsed);
Node **list = &((*client)->head);
char *command, *arg;
char name[MAX_ARG_LEN];
command = strtok(parsed, " ");
arg = strtok(NULL, " ");
memset(name, '\0', sizeof(name));
if(arg != NULL){
strcpy(name, arg);
}
if(strcmp(parsed, "exit") == 0){
printf("Client exits!\n");
if(state == 1){
printf("Finishing customer session.\n");
Node *node = findAccount((*client)->current_acc, *list);
Account *acc = node->account;
finishAccount(&acc, state);
free((*client)->current_acc);
}
update_client_count(-1);
free(parsed);
return -1;
}else if(strcmp(command, "open") == 0){
if(state == 1){
printf("Still in customer session!\n");
free(parsed);
return 1;
}
int open = openAccount(list, name);
char *msg = "Account opened for ";
printf("%s%s.\n", msg, name);
if(open == -1){
printf("Error opening account!\n");
free(parsed);
return 0;
}
free(parsed);
return 0;
}else if(strcmp(command, "start") == 0){
if(state == 0){
Node *ptr = findAccount(name, *list);
if(ptr == NULL){
free(parsed);
return 0;
}
Account *acc = ptr->account;
int n = startAccount(&acc, list);
if(n == 0){
printf("Account is still in use.\n");
free(parsed);
return 0;
}
char *current = malloc(strlen(name)*sizeof(char));
strcpy(current, name);
(*client)->current_acc = current;
free(parsed);
return 1;
}else{
printf("Still in session!\n");
free(parsed);
return 1;
}
}else if(strcmp(command, "credit") == 0){
if(state == 1){
float new = updateAccount((*client)->current_acc, list, atof(arg));
printf("Balance of %s is now %.2f.\n", (*client)->current_acc, new);
free(parsed);
return 1;
}else{
