void ScriptablePrivate::loadScript(const QString& oName)
{
qDebug() << "Looking for a script " << oName;
XSqlQuery scriptq;
scriptq.prepare("SELECT script_source, script_order"
" FROM script"
" WHERE((script_name=:script_name)"
" AND (script_enabled))"
" ORDER BY script_order;");
scriptq.bindValue(":script_name", oName);
scriptq.exec();
while(scriptq.next())
{
if(engine())
{
QString script = scriptHandleIncludes(scriptq.value("script_source").toString());
QScriptValue result = _engine->evaluate(script, _parent->objectName());
if (_engine->hasUncaughtException())
{
int line = _engine->uncaughtExceptionLineNumber();
qDebug() << "uncaught exception at line" << line << ":" << result.toString();
}
}
else
qDebug() << "could not initialize engine";
}
}
QSqlError pki_x509super::lookupKey()
{
XSqlQuery q;
unsigned hash = pubHash();
SQL_PREPARE(q, "SELECT item FROM public_keys WHERE hash=?");
q.bindValue(0, hash);
q.exec();
if (q.lastError().isValid())
return q.lastError();
while (q.next()) {
pki_key *x = db_base::lookupPki<pki_key>(q.value(0));
if (!x) {
qDebug("Public key with id %d not found",
q.value(0).toInt());
continue;
}
x->resetUcount();
if (compareRefKey(x)) {
setRefKey(x);
break;
}
}
return q.lastError();
}
void CSVAddMapInputDialog::populateTable()
{
XSqlQuery relq;
if (_schema->currentIndex() == 0)
relq.prepare("SELECT CASE nspname WHEN 'public' THEN relname"
" ELSE nspname || '.' || relname"
" END AS relname,"
" CASE nspname WHEN 'public' THEN 0 ELSE 1 END AS seq"
" FROM pg_class"
" JOIN pg_namespace ON (relnamespace=pg_namespace.oid)"
" WHERE ((relkind IN ('r', 'v'))"
" AND (nspname !~ '^pg_')"
" AND (nspname != 'information_schema'))"
" ORDER BY seq, relname;");
else
{
relq.prepare("SELECT relname"
" FROM pg_class"
" JOIN pg_namespace ON (relnamespace=pg_namespace.oid)"
" WHERE ((relkind IN ('r', 'v'))"
" AND (nspname = :nspname))"
" ORDER BY relname;");
relq.bindValue(":nspname", _schema->currentText());
}
if (relq.exec())
_table->clear();
while (relq.next())
_table->addItem(relq.value("relname").toString());
if (relq.lastError().type() != QSqlError::NoError)
{
QMessageBox::critical(this, tr("Database Error"), relq.lastError().text());
return;
}
}
int main(int /*argc*/, const char * /*argv*/[]) {
QTextOStream qout(stdout);
QFile file("test.mql");
if(file.open(IO_ReadOnly)) {
QTextStream stream(&file);
QString query = stream.read();
file.close();
MetaSQLQuery mql(query);
if(mql.isValid()) {
ParameterList params;
params.append("classcode_code", QVariant("^MA"));
qout << "The parsed query generated a valid object." << endl;
XSqlQuery qry = mql.toQuery(params);
while(qry.next()) {
qDebug("row");
}
} else {
qout << "The parsed query did not generate a valid object." << endl;
}
} else {
qout << "Unable to open '" << file.name() << "' for reading." << endl;
}
return 0;
}
void MetaSQLSaveParameters::sGetGroups()
{
ParameterList params;
if (_schema->currentText() == "public")
params.append("public");
else if (! _schema->currentText().isEmpty())
params.append("schema", _schema->currentText());
QString groups("SELECT DISTINCT metasql_group"
"<? if exists(\"public\") ?>"
" FROM ONLY metasql"
"<? elseif exists(\"schema\") ?>"
" FROM <? literal(\"schema\") ?>.pkgmetasql"
"<? else ?>"
" FROM metasql"
"<? endif ?>"
" ORDER BY metasql_group;");
MetaSQLQuery groupm(groups);
XSqlQuery groupq = groupm.toQuery(params);
groupq.exec();
_group->clear();
_group->addItem("");
while (groupq.next())
_group->addItem(groupq.value("metasql_group").toString());
if (groupq.lastError().type() != QSqlError::NoError)
QMessageBox::warning(this, tr("Database Errror"),
groupq.lastError().text());
_group->setCurrentIndex(-1);
}
bool XSqlQueryProto::next()
{
XSqlQuery *item = qscriptvalue_cast<XSqlQuery*>(thisObject());
if (item)
return item->next();
return false;
}
void postSubLedger::sPost()
{
QStringList sources;
QList<int> journalnumbers;
XSqlQuery qry;
MetaSQLQuery mql = mqlLoad("postSubLedger", "post");
QList<XTreeWidgetItem*> selected = _sources->selectedItems();
for (int i = 0; i < selected.size(); i++)
sources << selected.at(i)->rawValue("sltrans_source").toString();
ParameterList params;
_subLedgerDates->appendValue(params);
params.append("distDate", _distDate->date());
params.append("source_list", sources);
XSqlQuery jrnls;
jrnls = mql.toQuery(params);
if (jrnls.lastError().type() != QSqlError::NoError)
{
systemError(this, jrnls.lastError().databaseText(), __FILE__, __LINE__);
return;
}
while (jrnls.next())
journalnumbers << jrnls.value("result").toInt();
if (_print->isChecked() && journalnumbers.size())
sPrint(journalnumbers);
sFillList();
}
QWidget *ItemCharacteristicDelegate::createEditor(QWidget *parent,
const QStyleOptionViewItem & /*style*/,
const QModelIndex & index) const
{
if(index.column()!=1)
return 0;
QModelIndex idx = index.sibling(index.row(), CHAR);
characteristic::Type chartype = characteristic::Text;
// Determine what type we have
XSqlQuery qry;
qry.prepare("SELECT char_id, char_type "
"FROM char "
"WHERE (char_id=:char_id); ");
qry.bindValue(":char_id", idx.model()->data(idx, Qt::UserRole));
qry.exec();
if (qry.first())
chartype = (characteristic::Type)qry.value("char_type").toInt();
if (chartype == characteristic::Text ||
chartype == characteristic::List)
{
qry.prepare("SELECT charass_value "
"FROM char, charass "
" LEFT OUTER JOIN charopt ON ((charopt_char_id=charass_char_id) "
" AND (charopt_value=charass_value)) "
"WHERE ((charass_char_id=char_id)"
" AND (charass_target_type='I')"
" AND (charass_target_id=:item_id)"
" AND (char_id=:char_id) ) "
"ORDER BY COALESCE(charopt_order,0), charass_value;");
qry.bindValue(":char_id", idx.model()->data(idx, Qt::UserRole));
qry.bindValue(":item_id", index.model()->data(index, Xt::IdRole));
qry.exec();
QComboBox *editor = new QComboBox(parent);
editor->setEditable(chartype == characteristic::Text);
#ifdef Q_WS_MAC
QFont boxfont = editor->font();
boxfont.setPointSize((boxfont.pointSize() == -1) ? boxfont.pixelSize() - 3 : boxfont.pointSize() - 3);
editor->setFont(boxfont);
#endif
while(qry.next())
editor->addItem(qry.value("charass_value").toString());
editor->installEventFilter(const_cast<ItemCharacteristicDelegate*>(this));
return editor;
}
else if (chartype == characteristic::Date)
{
DLineEdit *editor = new DLineEdit(parent);
return editor;
}
return 0;
}
void assignLotSerial::sPrint()
{
QPrinter printer(QPrinter::HighResolution);
bool setupPrinter = true;
bool userCanceled = false;
QString label;
QString presetPrinter(xtsettingsValue(QString("%1.defaultPrinter").arg(objectName())).toString());
XSqlQuery qlabel;
qlabel.prepare("SELECT ls_id, itemsite_controlmethod "
"FROM itemlocdist "
"LEFT OUTER JOIN itemsite ON (itemlocdist_itemsite_id = itemsite_id) "
"JOIN ls ON (itemlocdist_ls_id=ls_id) "
"WHERE (itemlocdist_series=:itemlocdist_series) "
"ORDER BY ls_number;");
qlabel.bindValue(":itemlocdist_series", _itemlocSeries);
qlabel.exec();
if (qlabel.first()) {
if (qlabel.value("itemsite_controlmethod").toString() == "L")
label = tr("Lot#:");
else
label = tr("Serial#:");
if (presetPrinter.isEmpty()) {
if (orReport::beginMultiPrint(&printer, userCanceled) == false) {
if(!userCanceled) {
systemError(this, tr("<p>Could not initialize printing system for "
"multiple reports."));
return;
}
}
}
else {
printer.setPrinterName(presetPrinter);
orReport::beginMultiPrint(&printer);
}
for (int i = 0; i < qlabel.size(); i++) {
ParameterList params;
params.append("label", label);
params.append("ls_id", qlabel.value("ls_id").toInt());
orReport report("LotSerialLabel", params);
if (report.isValid() && report.print(&printer, setupPrinter))
setupPrinter = false;
else {
report.reportError(this);
break;
}
qlabel.next();
}
orReport::endMultiPrint(&printer);
}
else if (q.lastError().type() != QSqlError::NoError) {
systemError(this, q.lastError().databaseText(), __FILE__, __LINE__);
return;
}
}
user::user(QWidget* parent, const char * name, Qt::WindowFlags fl)
: XDialog(parent, name, fl)
{
setupUi(this);
_authCache = false;
_cUsername = "";
_crmacctid = -1;
_inTransaction = false;
_mode = cView;
connect(_close, SIGNAL(clicked()), this, SLOT(sClose()));
connect(_crmacct, SIGNAL(clicked()), this, SLOT(sCrmAccount()));
connect(_save, SIGNAL(clicked()), this, SLOT(sSave()));
connect(_add, SIGNAL(clicked()), this, SLOT(sAdd()));
connect(_addAll, SIGNAL(clicked()), this, SLOT(sAddAll()));
connect(_revoke, SIGNAL(clicked()), this, SLOT(sRevoke()));
connect(_revokeAll, SIGNAL(clicked()), this, SLOT(sRevokeAll()));
connect(_module, SIGNAL(activated(const QString&)), this, SLOT(sModuleSelected(const QString&)));
connect(_granted, SIGNAL(itemSelected(int)), this, SLOT(sRevoke()));
connect(_available, SIGNAL(itemSelected(int)), this, SLOT(sAdd()));
connect(_username, SIGNAL(editingFinished()), this, SLOT(sCheck()));
connect(_enhancedAuth, SIGNAL(toggled(bool)), this, SLOT(sEnhancedAuthUpdate()));
connect(_grantedGroup, SIGNAL(itemSelected(int)), this, SLOT(sRevokeGroup()));
connect(_availableGroup, SIGNAL(itemSelected(int)), this, SLOT(sAddGroup()));
connect(_addGroup, SIGNAL(clicked()), this, SLOT(sAddGroup()));
connect(_revokeGroup, SIGNAL(clicked()), this, SLOT(sRevokeGroup()));
connect(_grantedSite, SIGNAL(itemSelected(int)), this, SLOT(sRevokeSite()));
connect(_availableSite, SIGNAL(itemSelected(int)), this, SLOT(sAddSite()));
connect(_addSite, SIGNAL(clicked()), this, SLOT(sAddSite()));
connect(_revokeSite, SIGNAL(clicked()), this, SLOT(sRevokeSite()));
_available->addColumn("Available Privileges", -1, Qt::AlignLeft);
_granted->addColumn("Granted Privileges", -1, Qt::AlignLeft);
_availableGroup->addColumn("Available Roles", -1, Qt::AlignLeft);
_grantedGroup->addColumn("Granted Roles", -1, Qt::AlignLeft);
_availableSite->addColumn("Available Sites", -1, Qt::AlignLeft);
_grantedSite->addColumn("Granted Sites", -1, Qt::AlignLeft);
_locale->setType(XComboBox::Locales);
XSqlQuery modq;
modq.exec( "SELECT DISTINCT priv_module FROM priv ORDER BY priv_module;" );
for (int i = 0; modq.next(); i++)
_module->append(i, modq.value("priv_module").toString());
if(_evaluation == true)
{
_enhancedAuth->setEnabled(false);
_passwd->setEnabled(false);
_verify->setEnabled(false);
}
if (!_metrics->boolean("MultiWhs"))
_tab->removeTab(_tab->indexOf(_siteTab));
}
void purchaseOrderItem::sPopulateItemChar()
{
XSqlQuery item;
item.prepare( "SELECT char_id, char_name, "
" CASE WHEN char_type < 2 THEN "
" charass_value "
" ELSE "
" formatDate(charass_value::date) "
" END AS f_charass_value, "
" charass_value, charass_value AS charass_value_qttooltiprole "
" FROM ( "
" SELECT char_id, char_type, char_name, "
" COALESCE(pi.charass_value,i2.charass_value) AS charass_value "
" FROM "
" (SELECT DISTINCT char_id, char_type, char_name "
" FROM charass, char, charuse "
" WHERE ((charass_char_id=char_id) "
" AND (charuse_char_id=char_id AND charuse_target_type='PI') "
" AND (charass_target_type='I') "
" AND (charass_target_id=:item_id) )"
" UNION SELECT char_id, char_type, char_name "
" FROM charass, char "
" WHERE ((charass_char_id=char_id) "
" AND charass_char_id IN (SELECT charuse_char_id FROM charuse"
" WHERE charuse_target_type = 'I')"
" AND (charass_target_type = 'PI' AND charass_target_id=:poitem_id)) ) AS data "
" LEFT OUTER JOIN charass pi ON ((:poitem_id=pi.charass_target_id) "
" AND ('PI'=pi.charass_target_type) "
" AND (pi.charass_char_id=char_id)) "
" LEFT OUTER JOIN item i1 ON (i1.item_id=:item_id) "
" LEFT OUTER JOIN charass i2 ON ((i1.item_id=i2.charass_target_id) "
" AND ('I'=i2.charass_target_type) "
" AND (i2.charass_char_id=char_id) "
" AND (i2.charass_default))) data2 "
" ORDER BY char_name;" );
item.bindValue(":item_id", _item->id());
item.bindValue(":poitem_id", _poitemid);
item.exec();
int row = 0;
_itemchar->removeRows(0, _itemchar->rowCount());
QModelIndex idx;
while(item.next())
{
_itemchar->insertRow(_itemchar->rowCount());
idx = _itemchar->index(row, 0);
_itemchar->setData(idx, item.value("char_name"), Qt::DisplayRole);
_itemchar->setData(idx, item.value("char_id"), Qt::UserRole);
idx = _itemchar->index(row, 1);
_itemchar->setData(idx, item.value("charass_value"), Qt::DisplayRole);
_itemchar->setData(idx, _item->id(), Xt::IdRole);
_itemchar->setData(idx, _item->id(), Qt::UserRole);
row++;
}
}
void voidChecks::sVoid()
{
XSqlQuery voidVoid;
voidVoid.prepare("SELECT checkhead_id, checkhead_number,"
" voidCheck(checkhead_id) AS result"
" FROM checkhead"
" WHERE ((NOT checkhead_posted)"
" AND (NOT checkhead_replaced)"
" AND (NOT checkhead_deleted)"
" AND (NOT checkhead_void)"
" AND (checkhead_bankaccnt_id=:bankaccnt_id))");
voidVoid.bindValue(":bankaccnt_id", _bankaccnt->id());
voidVoid.exec();
while (voidVoid.next())
{
int result = voidVoid.value("result").toInt();
if (result < 0)
systemError(this,
tr("Check %1").arg(voidVoid.value("checkhead_number").toString()) +
"\n" + storedProcErrorLookup("voidCheck", result),
__FILE__, __LINE__);
else if(_issueReplacements->isChecked())
{
XSqlQuery rplc;
rplc.prepare("SELECT replaceVoidedCheck(:checkhead_id) AS result;");
while(voidVoid.next())
{
rplc.bindValue(":checkhead_id", voidVoid.value("checkhead_id").toInt());
rplc.exec();
}
}
omfgThis->sChecksUpdated(_bankaccnt->id(), -1, TRUE);
}
if (voidVoid.lastError().type() != QSqlError::NoError)
{
systemError(this, voidVoid.lastError().databaseText(), __FILE__, __LINE__);
return;
}
accept();
}
QString ExportHelper::generateHTML(QString qtext, ParameterList ¶ms, QString &errmsg)
{
if (DEBUG)
qDebug("ExportHelper::generateHTML(%s..., %d params, errmsg) entered",
qPrintable(qtext.left(80)), params.size());
if (qtext.isEmpty())
return QString::null;
QTextDocument doc(0);
QTextCursor cursor(&doc);
QTextTableFormat tablefmt;
bool valid;
QVariant includeheaderVar = params.value("includeHeaderLine", &valid);
bool includeheader = (valid ? includeheaderVar.toBool() : false);
if (DEBUG)
qDebug("generateHTML(qtest, params, errmsg) includeheader = %d, valid = %d",
includeheader, valid);
MetaSQLQuery mql(qtext);
XSqlQuery qry = mql.toQuery(params);
if (qry.first())
{
int cols = qry.record().count();
int expected = qry.size();
if (includeheader)
expected++;
// presize the table
cursor.insertTable((expected < 0 ? 1 : expected), cols, tablefmt);
if (includeheader)
{
tablefmt.setHeaderRowCount(1);
for (int p = 0; p < cols; p++)
{
cursor.insertText(qry.record().fieldName(p));
cursor.movePosition(QTextCursor::NextCell);
}
}
do {
for (int i = 0; i < cols; i++)
{
cursor.insertText(qry.value(i).toString());
cursor.movePosition(QTextCursor::NextCell);
}
} while (qry.next());
}
if (qry.lastError().type() != QSqlError::NoError)
errmsg = qry.lastError().text();
return doc.toHtml();
}
void QueryEditor::groupEditTextChanged(const QString & t)
{
XSqlQuery xqry;
xqry.prepare("SELECT DISTINCT metasql_name FROM metasql WHERE metasql_group=:group ORDER BY metasql_name;");
xqry.bindValue(":group", t);
if(xqry.exec())
{
_mqlName->clear();
while(xqry.next())
_mqlName->addItem(xqry.value(0).toString());
}
}
void Parameters::load()
{
_values.clear();
XSqlQuery q;
q.prepare(_readSql);
q.bindValue(":username", _username);
q.exec();
while (q.next())
_values[q.value("key").toString()] = q.value("value").toString();
_dirty = FALSE;
}
QString scriptHandleIncludes(QString source)
{
QString returnVal = source;
if (returnVal.contains(QRegExp("#include")))
{
QStringList line = returnVal.split(QRegExp("\n\r?|\r\n?"));
for (int i = 0; i < line.size(); i++)
{
if (line.at(i).startsWith("#include"))
{
QStringList words = line.at(i).split(QRegExp("\\s+"));
if (words.size() <= 1)
qWarning("scriptByName(%s): found #include with no script name",
qPrintable(line.at(i)));
int order = -1;
if (words.size() > 2)
order = words.at(2).toInt();
QString name;
if (words.size() > 1)
name = words.at(1);
line.replace(i, "// " + line.at(i));
XSqlQuery inclq;
inclq.prepare("SELECT script_source "
"FROM script "
"WHERE ((script_name=:name)"
" AND ((script_order=:order) OR (:order = -1))"
" AND script_enabled) "
"ORDER BY script_order;");
inclq.bindValue(":name", name);
inclq.bindValue(":order", order);
inclq.exec();
bool found = false;
while (inclq.next())
{
found = true;
line.replace(i,
line.at(i) + "\n" + scriptHandleIncludes(inclq.value("script_source").toString()));
}
if (found)
line.replace(i,
line.at(i) + "\n// end include of " + name);
}
}
returnVal = line.join("\n");
}
return returnVal;
}
void financialLayoutGroup::sFillGroupList()
{
XSqlQuery financialFillGroupList;
_group->clear();
financialFillGroupList.prepare("SELECT flgrp_id, flgrp_name"
" FROM flgrp"
" WHERE (flgrp_flhead_id=:flhead_id)"
" ORDER BY flgrp_name;");
financialFillGroupList.bindValue(":flhead_id", _flheadid);
financialFillGroupList.exec();
_group->append(-1, tr("Parent"));
while(financialFillGroupList.next())
_group->append(financialFillGroupList.value("flgrp_id").toInt(), financialFillGroupList.value("flgrp_name").toString());
}
QString ExportHelper::generateXML(QString qtext, QString tableElemName, ParameterList ¶ms, QString &errmsg, int xsltmapid)
{
if (DEBUG)
qDebug("ExportHelper::generateXML(%s..., %s, %d params, errmsg, %d) entered",
qPrintable(qtext.left(80)), qPrintable(tableElemName),
params.size(), xsltmapid);
if (DEBUG)
{
QStringList plist;
for (int i = 0; i < params.size(); i++)
plist.append("\t" + params.name(i) + ":\t" + params.value(i).toString());
qDebug("generateXML parameters:\n%s", qPrintable(plist.join("\n")));
}
QDomDocument xmldoc("xtupleimport");
QDomElement rootelem = xmldoc.createElement("xtupleimport");
xmldoc.appendChild(rootelem);
if (! qtext.isEmpty())
{
MetaSQLQuery mql(qtext);
XSqlQuery qry = mql.toQuery(params);
if (qry.first())
{
do {
QDomElement tableElem = xmldoc.createElement(tableElemName);
if (DEBUG)
qDebug("generateXML starting %s", qPrintable(tableElemName));
for (int i = 0; i < qry.record().count(); i++)
{
QDomElement fieldElem = xmldoc.createElement(qry.record().fieldName(i));
if (qry.record().value(i).isNull())
fieldElem.appendChild(xmldoc.createTextNode("[NULL]"));
else
fieldElem.appendChild(xmldoc.createTextNode(qry.record().value(i).toString()));
tableElem.appendChild(fieldElem);
}
rootelem.appendChild(tableElem);
} while (qry.next());
}
if (qry.lastError().type() != QSqlError::NoError)
errmsg = qry.lastError().text();
}
if (xsltmapid < 0)
return xmldoc.toString();
else
return XSLTConvertString(xmldoc.toString(), xsltmapid, errmsg);
}
QString ExportHelper::generateDelimited(const int qryheadid, ParameterList ¶ms, QString &errmsg)
{
if (DEBUG)
qDebug("ExportHelper::exportDelimited(%d, %d params, errmsgd) entered",
qryheadid, params.size());
QStringList result;
XSqlQuery itemq;
itemq.prepare("SELECT *"
" FROM qryitem"
" WHERE qryitem_qryhead_id=:id"
" ORDER BY qryitem_order;");
itemq.bindValue(":id", qryheadid);
itemq.exec();
while (itemq.next())
{
QString qtext;
if (itemq.value("qryitem_src").toString() == "REL")
{
QString schemaName = itemq.value("qryitem_group").toString();
qtext = "SELECT * FROM " +
(schemaName.isEmpty() ? QString("") : schemaName + QString(".")) +
itemq.value("qryitem_detail").toString();
}
else if (itemq.value("qryitem_src").toString() == "MQL")
{
QString tmpmsg;
bool valid;
qtext = MQLUtil::mqlLoad(itemq.value("qryitem_group").toString(),
itemq.value("qryitem_detail").toString(),
tmpmsg, &valid);
if (! valid)
errmsg = tmpmsg;
}
else if (itemq.value("qryitem_src").toString() == "CUSTOM")
qtext = itemq.value("qryitem_detail").toString();
if (! qtext.isEmpty())
{
QString oneresult = generateDelimited(qtext, params, errmsg);
if (! oneresult.isEmpty())
result.append(oneresult);
}
}
if (itemq.lastError().type() != QSqlError::NoError)
errmsg = itemq.lastError().text();
return result.join("\n");
}
void MQLEdit::execQuery()
{
if(!_loggedIn) {
QMessageBox::warning(this, tr("Not Connected"),
tr("You must be connected to a database in order to execute a query."));
return;
}
_results->_table->setRowCount(0);
_results->_table->setColumnCount(0);
_sql->_log->clear();
_log->_log->clear();
_log->_log->append(tr("---- Parsing Query ----\n"));
MetaSQLQuery mql(_text->toPlainText());
_log->_log->append(mql.parseLog());
if(mql.isValid()) {
_log->_log->append(tr("Query parsed."));
_log->_log->append(tr("---- Executing Query ----"));
ParameterList plist = _pEdit->getParameterList();
XSqlQuery qry = mql.toQuery(plist);
_sql->_log->append(qry.executedQuery());
if(qry.isActive()) {
QSqlRecord rec = qry.record();
int ncols = rec.count();
_results->_table->setColumnCount(ncols);
int c;
for(c = 0; c < ncols; c++) {
_results->_table->setHorizontalHeaderItem(c, new QTableWidgetItem(rec.fieldName(c)));
}
int nrows = 0;
while(qry.next()) {
_results->_table->setRowCount(nrows + 1);
for(c = 0; c < ncols; c++) {
_results->_table->setItem(nrows, c, new QTableWidgetItem(qry.value(c).toString()));
}
nrows++;
}
showResults();
} else {
_log->_log->append(tr("Failed to execute query."));
QSqlError err = qry.lastError();
_log->_log->append(err.text());
}
} else {
_log->_log->append(tr("ERROR: Invalid query!"));
showLog();
}
}
void updateItemSiteLeadTimes::sUpdate()
{
ParameterList params;
_warehouse->appendValue(params);
_classCode->appendValue(params);
XSqlQuery updateUpdate;
QProgressDialog progress;
progress.setWindowModality(Qt::ApplicationModal);
MetaSQLQuery mql = mqlLoad("updateItemsiteLeadTimes", "load");
updateUpdate = mql.toQuery(params);
if (ErrorReporter::error(QtCriticalMsg, this, tr("Error Loading Item Site Lead Times"),
updateUpdate, __FILE__, __LINE__))
{
return;
}
int count=0;
progress.setMaximum(updateUpdate.size());
XSqlQuery update;
while (updateUpdate.next())
{
progress.setLabelText(tr("Site: %1\n"
"Item: %2 - %3")
.arg(updateUpdate.value("warehous_code").toString())
.arg(updateUpdate.value("item_number").toString())
.arg(updateUpdate.value("item_descrip1").toString()));
ParameterList rparams = params;
rparams.append("itemsite_id", updateUpdate.value("itemsite_id"));
rparams.append("leadTimePad", _leadTimePad->value());
MetaSQLQuery mql2 = mqlLoad("updateItemsiteLeadTimes", "update");
update = mql2.toQuery(rparams);
if (ErrorReporter::error(QtCriticalMsg, this, tr("Error Updating Item Site Lead Times"),
update, __FILE__, __LINE__))
{
return;
}
if (progress.wasCanceled())
break;
count++;
progress.setValue(count);
}
accept();
}
void XWidget::loadScriptEngine()
{
if(_private->_scriptLoaded)
return;
_private->_scriptLoaded = true;
QStringList parts = objectName().split(" ");
QStringList search_parts;
QString oName;
while(!parts.isEmpty())
{
search_parts.append(parts.takeFirst());
oName = search_parts.join(" ");
// load and run an QtScript that applies to this window
qDebug() << "Looking for a script on widget " << oName;
XSqlQuery scriptq;
scriptq.prepare("SELECT script_source, script_order"
" FROM script"
" WHERE((script_name=:script_name)"
" AND (script_enabled))"
" ORDER BY script_order;");
scriptq.bindValue(":script_name", oName);
scriptq.exec();
while(scriptq.next())
{
QString script = scriptHandleIncludes(scriptq.value("script_source").toString());
if(!_private->_engine)
{
_private->_engine = new QScriptEngine();
if (_preferences->boolean("EnableScriptDebug"))
{
_private->_debugger = new QScriptEngineDebugger(this);
_private->_debugger->attachTo(_private->_engine);
}
omfgThis->loadScriptGlobals(_private->_engine);
QScriptValue mywindow = _private->_engine->newQObject(this);
_private->_engine->globalObject().setProperty("mywindow", mywindow);
}
QScriptValue result = _private->_engine->evaluate(script, objectName());
if (_private->_engine->hasUncaughtException())
{
int line = _private->_engine->uncaughtExceptionLineNumber();
qDebug() << "uncaught exception at line" << line << ":" << result.toString();
}
}
}
}
void itemAliasList::sFillList()
{
_item->clear();
if (_alias->text().trimmed().length() == 0)
return;
QString pre( "SELECT item_id, itemalias_id, itemalias_number, item_number, (item_descrip1 || ' ' || item_descrip2) AS item_descrip "
"FROM (SELECT DISTINCT item_id, item_number, item_descrip1, item_descrip2");
QString post(") AS data, itemalias "
"WHERE ( (itemalias_item_id=item_id)"
" AND (UPPER(itemalias_number)~UPPER(:searchString)) )" );
if(_x_preferences && _x_preferences->boolean("ListNumericItemNumbersFirst"))
post += " ORDER BY toNumeric(item_number, 999999999999999), item_number";
else
post += " ORDER BY item_number";
QStringList clauses;
clauses = _extraClauses;
if ( !(_itemType & ItemLineEdit::cActive) && !_showInactive->isChecked())
clauses << "(item_active)";
XSqlQuery alias;
alias.prepare(buildItemLineEditQuery(pre, clauses, post, _itemType));
alias.bindValue(":searchString", _alias->text().trimmed());
alias.exec();
if (alias.first())
{
if (_useQuery)
{
XSqlQuery item(_sql);
if (item.first())
{
XTreeWidgetItem *last = NULL;
do
{
if (item.findFirst("item_id", alias.value("item_id").toInt()) != -1)
last = new XTreeWidgetItem( _item, last, alias.value("item_id").toInt(), alias.value("itemalias_id").toInt(),
alias.value("itemalias_number").toString(), alias.value("item_number").toString(), alias.value("item_descrip").toString() );
}
while (alias.next());
}
}
else
_item->populate(alias, TRUE);
}
}
void displayPrivate::setupCharacteristics(QStringList uses)
{
QString column;
QString name;
QString sql = QString("SELECT char_id, char_name, char_type "
"FROM char "
" JOIN charuse ON char_id = charuse_char_id"
" WHERE char_search "
" AND charuse_target_type IN ('%1')"
" ORDER BY char_name;").arg(uses.join("','"));
XSqlQuery chars;
chars.exec(sql);
if (chars.size() <= 0)
{
qWarning() << "Could not find any characteristics matching" << uses;
}
while (chars.next())
{
characteristic::Type chartype = (characteristic::Type)chars.value("char_type").toInt();
column = QString("char%1").arg(chars.value("char_id").toString());
name = chars.value("char_name").toString();
_list->addColumn(name, -1, Qt::AlignLeft , false, column );
if (chartype == characteristic::Text)
{
_charidstext.append(chars.value("char_id").toInt());
_parameterWidget->append(name, column, ParameterWidget::Text);
}
else if (chartype == characteristic::List)
{
_charidslist.append(chars.value("char_id").toInt());
QString sql = QString("SELECT charopt_value, charopt_value "
"FROM charopt "
"WHERE (charopt_char_id=%1);")
.arg(chars.value("char_id").toInt());
_parameterWidget->append(name, column, ParameterWidget::Multiselect, QVariant(), false, sql);
}
else if (chartype == characteristic::Date)
{
_charidsdate.append(chars.value("char_id").toInt());
QString start = QApplication::translate("display", "Start Date", 0);
QString end = QApplication::translate("display", "End Date", 0);
_parameterWidget->append(name + " " + start, column + "startDate", ParameterWidget::Date);
_parameterWidget->append(name + " " + end, column + "endDate", ParameterWidget::Date);
}
}
}
void ContactList::sFillList()
{
_listTab->clear();
XSqlQuery query;
query.prepare(_parent->_query +
_parent->_extraClause +
" ORDER BY cntct_last_name, cntct_first_name;");
query.bindValue(":crmacct_id", _parent->_crmAcct->id());
query.bindValue(":searchAcctId", _parent->_searchAcctId);
query.exec();
query.first();
if (query.lastError().type() != QSqlError::None)
{
QMessageBox::critical(this, tr("A System Error Occurred at %1::%2.")
.arg(__FILE__)
.arg(__LINE__),
query.lastError().databaseText());
return;
}
else if (query.size() < 1) // no rows found with limit so try without
{
query.prepare(_parent->_query +
" ORDER BY cntct_last_name, cntct_first_name;");
query.exec();
query.first();
if (query.lastError().type() != QSqlError::None)
{
QMessageBox::critical(this, tr("A System Error Occurred at %1::%2.")
.arg(__FILE__)
.arg(__LINE__),
query.lastError().databaseText());
return;
}
}
XTreeWidgetItem *last = 0;
do {
last = new XTreeWidgetItem(_listTab, last,
query.value("cntct_id").toInt(), 0,
query.value("cntct_number"),
query.value("cntct_first_name"),
query.value("cntct_last_name"),
query.value("crmacct_name"));
} while (query.next());
}
void AddressList::sFillList()
{
_listTab->clear();
XSqlQuery query;
query.prepare(_parent->_query +
_parent->_extraClause +
" ORDER BY addr_country, addr_state, addr_postalcode;");
query.exec();
query.first();
if (query.lastError().type() != QSqlError::None)
{
QMessageBox::critical(this, tr("A System Error Occurred at %1::%2.")
.arg(__FILE__)
.arg(__LINE__),
query.lastError().databaseText());
return;
}
else if (query.size() < 1)// no rows found with limit so try without
{
query.prepare(_parent->_query +
" ORDER BY addr_country, addr_state, addr_postalcode;");
query.exec();
query.first();
if (query.lastError().type() != QSqlError::None)
{
QMessageBox::critical(this, tr("A System Error Occurred at %1::%2.")
.arg(__FILE__)
.arg(__LINE__),
query.lastError().databaseText());
return;
}
}
XTreeWidgetItem *last = NULL;
do {
last = new XTreeWidgetItem(_listTab, last,
query.value("addr_id").toInt(), 0,
query.value("addr_line1"),
query.value("addr_line2"),
query.value("addr_line3"),
query.value("addr_city"),
query.value("addr_state"),
query.value("addr_country"),
query.value("addr_postalcode"));
} while (query.next());
}
void XComboBox::populate(XSqlQuery &pQuery, int pSelected)
{
int selected = 0;
int counter = 0;
// Clear any old data
clear();
if (allowNull())
counter++;
// Load the combobox with the contents of the passed query, if any
if (pQuery.first())
{
do
{
append(pQuery.value(0).toInt(), pQuery.value(1).toString(), pQuery.value(2).toString());
if (pQuery.value(0).toInt() == pSelected)
selected = counter;
counter++;
}
while(pQuery.next());
}
setCurrentIndex(selected);
if (_ids.count())
{
_lastId = _ids.at(selected);
if (allowNull())
emit notNull(TRUE);
}
else
{
_lastId = -1;
if (allowNull())
emit notNull(FALSE);
}
emit newID(_lastId);
emit valid((_lastId != -1));
}
QueryEditor::QueryEditor(QWidget* parent, Qt::WindowFlags fl)
: QDialog(parent, fl)
{
setupUi(this);
// signals and slots connections
connect(_metasql, SIGNAL(toggled(bool)), this, SLOT(mqlToggled(bool)));
connect(_mqlGroup, SIGNAL(editTextChanged(QString)), this, SLOT(groupEditTextChanged(QString)));
connect(_mqlName, SIGNAL(editTextChanged(QString)), this, SLOT(nameEditTextChanged(QString)));
XSqlQuery xqry;
if(xqry.exec("SELECT distinct metasql_group FROM metasql ORDER BY metasql_group;"))
{
_mqlGroup->clear();
while(xqry.next())
_mqlGroup->addItem(xqry.value(0).toString());
}
}
void createPlannedOrdersByPlannerCode::sCreate(ParameterList params)
{
XSqlQuery createCreate;
QProgressDialog progress;
progress.setWindowModality(Qt::ApplicationModal);
MetaSQLQuery mql = mqlLoad("schedule", "load");
createCreate = mql.toQuery(params);
if (createCreate.lastError().type() != QSqlError::NoError)
{
systemError(this, createCreate.lastError().databaseText(), __FILE__, __LINE__);
return;
}
int count=0;
progress.setMaximum(createCreate.size());
XSqlQuery create;
while (createCreate.next())
{
progress.setLabelText(tr("Site: %1\n"
"Item: %2 - %3")
.arg(createCreate.value("warehous_code").toString())
.arg(createCreate.value("item_number").toString())
.arg(createCreate.value("item_descrip1").toString()));
ParameterList rparams = params;
rparams.append("itemsite_id", createCreate.value("itemsite_id"));
MetaSQLQuery mql2 = mqlLoad("schedule", "create");
create = mql2.toQuery(rparams);
if (create.lastError().type() != QSqlError::NoError)
{
systemError(this, create.lastError().databaseText(), __FILE__, __LINE__);
return;
}
if (progress.wasCanceled())
break;
count++;
progress.setValue(count);
}
accept();
}
QString ExportHelper::generateHTML(const int qryheadid, ParameterList ¶ms, QString &errmsg)
{
if (DEBUG)
qDebug("ExportHelper::generateHTML(%d, %d params, errmsg) entered",
qryheadid, params.size());
QTextDocument doc(0);
QTextCursor cursor(&doc);
XSqlQuery itemq;
itemq.prepare("SELECT * FROM qryitem WHERE qryitem_qryhead_id=:id ORDER BY qryitem_order;");
itemq.bindValue(":id", qryheadid);
itemq.exec();
while (itemq.next())
{
QString qtext;
if (itemq.value("qryitem_src").toString() == "REL")
{
QString schemaName = itemq.value("qryitem_group").toString();
qtext = "SELECT * FROM " +
(schemaName.isEmpty() ? QString("") : schemaName + QString(".")) +
itemq.value("qryitem_detail").toString();
}
else if (itemq.value("qryitem_src").toString() == "MQL")
{
QString tmpmsg;
bool valid;
qtext = MQLUtil::mqlLoad(itemq.value("qryitem_group").toString(),
itemq.value("qryitem_detail").toString(),
tmpmsg, &valid);
if (! valid)
errmsg = tmpmsg;
}
else if (itemq.value("qryitem_src").toString() == "CUSTOM")
qtext = itemq.value("qryitem_detail").toString();
if (! qtext.isEmpty())
cursor.insertHtml(generateHTML(qtext, params, errmsg));
}
if (itemq.lastError().type() != QSqlError::NoError)
errmsg = itemq.lastError().text();
return doc.toHtml();
}
