void RacomClient::init() { QF_SAFE_DELETE(m_rawSIDataUdpSocket); QF_SAFE_DELETE(m_sirxdDataServer); RacomClientSettings ss = settings(); qfDebug() << ss; if(ss.isListenRawData()) { m_rawSIDataUdpSocket = new QUdpSocket(this); if(m_rawSIDataUdpSocket->bind(ss.rawDataListenPort())) { connect(m_rawSIDataUdpSocket, &QUdpSocket::readyRead, this, &RacomClient::onRawSIDataUdpSocketReadyRead); connect(m_rawSIDataUdpSocket, QOverload<QAbstractSocket::SocketError>::of(&QAbstractSocket::error), [](QAbstractSocket::SocketError) { qfError() << "RacomClient: raw SI data UDP socket error"; }); } else { qfError() << "Cannot bind raw SI data UDP socket to port:" << ss.rawDataListenPort(); } qfInfo() << "raw SI data UDP socket listenning on port:" << ss.rawDataListenPort(); } if(ss.isListenSirxdData()) { m_sirxdDataServer = new QTcpServer(this); if (!m_sirxdDataServer->listen(QHostAddress::Any, ss.sirxdDataListenPort())) { qfError() << "RacomClient: Sirxd TCP server cannot listen on port:" << ss.sirxdDataListenPort(); } else { connect(m_sirxdDataServer, &QTcpServer::newConnection, [this](){ QTcpSocket *sock = m_sirxdDataServer->nextPendingConnection(); new RacomClientSirxdConnection(sock, m_sirxdDataServer); }); } qfInfo() << "Sirxd TCP server listenning on port:" << ss.sirxdDataListenPort(); } }
bool EventPlugin::closeEvent() { qfLogFuncFrame(); m_classNameCache.clear(); setEventName(QString()); QF_SAFE_DELETE(m_eventConfig); emit eventOpened(eventName()); //comment it till QE can load event with invalid name return true; }
void ReceiptsPlugin::setReceiptsPrinterOptions(const ReceiptsPrinterOptions &opts) { QString printer_options_key = ReceiptsPlugin::SETTINGS_PREFIX; printer_options_key += "receiptsPrinter"; qf::core::utils::Settings settings; QByteArray ba = opts.toJson(); QString s = QString::fromUtf8(ba); settings.setValue(printer_options_key, s); QF_SAFE_DELETE(m_receiptsPrinter); }
int main(int argc, char *argv[]) { if(argc <= 2) { QString arg = "-h"; if(argc > 1) arg = argv[1]; if(arg == QStringLiteral("-h") || arg == QStringLiteral("--help")) { std::cout << argv[0] << " FUSE_options --dbfs DBFS_options" << std::endl; std::cout << "FUSE_options" << std::endl; std::cout << "\tuse -h --dbfs switch to print FUSE options" << std::endl; std::cout << "DBFS_options" << std::endl; std::cout << "\t--dbfs\t" << "DBFS options separator, all options prior this will be ignored by DBFS" << std::endl; std::cout << "\t--host <host>\t" << "Database host" << std::endl; std::cout << "\t--port <port>\t" << "Database port" << std::endl; std::cout << "\t -u" << std::endl; std::cout << "\t--user <user>\t" << "Database user" << std::endl; std::cout << "\t -p" << std::endl; std::cout << "\t--password [<password>]\t" << "Database user password, use -p without password for interactive input." << std::endl; std::cout << "\t--database <database>\t" << "Database name" << std::endl; std::cout << "\t--db-schema\t" << "Database schema name" << std::endl; std::cout << "\t--table-name\t" << "DBFS table name, default is 'dbfs'" << std::endl; std::cout << "\t--create\t" << "Create DBFS tables" << std::endl; exit(0); } } int dbfs_switch_index; for(dbfs_switch_index = 1; dbfs_switch_index < argc; dbfs_switch_index++) if(argv[dbfs_switch_index] == QLatin1String("--dbfs")) { break; } QScopedPointer<qf::core::LogDevice> file_log_device(qf::core::FileLogDevice::install()); file_log_device->setDomainTresholds(argc - dbfs_switch_index, argv + dbfs_switch_index); file_log_device->setPrettyDomain(true); QString o_database; QString o_user; QString o_password; QString o_host; int o_port = 0; QString o_db_schema; QString o_table_name; bool o_create_db = false; bool o_ask_passwd = false; for(int i=dbfs_switch_index + 1; i<argc; i++) { QString arg = argv[i]; if(arg == QStringLiteral("--host")) { if(i<argc-1) { i++; o_host = argv[i]; } } else if(arg == QStringLiteral("--port")) { if(i<argc-1) { i++; o_port = QString(argv[i]).toInt(); } } else if(arg == QStringLiteral("-u") || arg == QStringLiteral("--user")) { if(i<argc-1) { i++; o_user = argv[i]; } } else if(arg == QStringLiteral("-p") || arg == QStringLiteral("--password")) { if(i<argc-1) { QString p = argv[i+1]; if(p.startsWith('-')) { o_ask_passwd = true; } else { o_password = p; i++; } } else { o_ask_passwd = true; } } else if(arg == QStringLiteral("--database")) { if(i<argc-1) { i++; o_database = argv[i]; } } else if(arg == QStringLiteral("--db-schema")) { if(i<argc-1) { i++; o_db_schema = argv[i]; } } else if(arg == QStringLiteral("--table-name")) { if(i<argc-1) { i++; o_table_name = argv[i]; } } else if(arg == QStringLiteral("--create")) { o_create_db = true; } } if(o_ask_passwd) { char pwd[256]; std::cout << "Please, enter your password: "******"Empty database name."; exit(1); } qfs::DbFsDriver *dbfs_drv = nullptr; qf::core::sql::Connection db_connection; if(dbfs_switch_index < (argc - 1)) { db_connection = QSqlDatabase::addDatabase("QPSQL"); db_connection.setHostName(o_host); if(o_port > 0) db_connection.setPort(o_port); db_connection.setDatabaseName(o_database); db_connection.setUserName(o_user); db_connection.setPassword(o_password); //qfInfo() << o_host << o_port << o_user << o_database; bool ok = db_connection.open(); if(!ok) { qfError() << db_connection.lastError().text(); exit(1); } if(!o_db_schema.isEmpty()) { if(!db_connection.setCurrentSchema(o_db_schema)) { qfError() << "Error setting db schema to:" << o_db_schema; exit(1); } } dbfs_drv = new qfs::DbFsDriver(); dbfs_drv->setConnectionName(db_connection.connectionName()); if(!o_table_name.isEmpty()) { dbfs_drv->setTableName(o_table_name); } if(o_create_db) { if(!dbfs_drv->createDbFs()) { qfError() << "Error creating dbfs table" << dbfs_drv->tableName(); } exit(1); } qfsqldbfs_setdriver(dbfs_drv); } int fuse_argc = dbfs_switch_index; /// FUSE variables struct fuse_args fuse_arguments = FUSE_ARGS_INIT(fuse_argc, argv); struct fuse_chan *fuse_channel = NULL; struct fuse *fuse_handle = NULL; char *mount_point = nullptr; if (fuse_parse_cmdline(&fuse_arguments, &mount_point, NULL, NULL) == -1) { qfError() << "fuse_parse_cmdline() - Error parsing fuse command line arguments!"; exit(1); } /// Tell FUSE where the local mountpoint is fuse_channel = fuse_mount(mount_point, &fuse_arguments); if (fuse_channel == NULL){ qfError()<<"fuse_mount() failed"; exit(1); } // Tell FUSE about implementations of FS operations struct fuse_operations fuse_ops; memset(&fuse_ops, 0, sizeof(fuse_ops)); fuse_ops.getattr = qfsqldbfs_getattr; fuse_ops.readdir = qfsqldbfs_readdir; fuse_ops.open = qfsqldbfs_open; fuse_ops.read = qfsqldbfs_read; fuse_ops.write = qfsqldbfs_write; fuse_ops.fsync = qfsqldbfs_fsync; fuse_ops.flush = qfsqldbfs_flush; fuse_ops.release = qfsqldbfs_release; fuse_ops.mknod = qfsqldbfs_mknod; fuse_ops.mkdir = qfsqldbfs_mkdir; fuse_ops.unlink = qfsqldbfs_unlink; fuse_ops.rmdir = qfsqldbfs_rmdir; fuse_ops.utime = qfsqldbfs_utime; fuse_ops.truncate = qfsqldbfs_truncate; fuse_ops.ftruncate = qfsqldbfs_ftruncate; fuse_ops.chmod = qfsqldbfs_chmod; fuse_ops.chown = qfsqldbfs_chown; fuse_ops.create = qfsqldbfs_create; fuse_ops.rename = qfsqldbfs_rename; fuse_handle = fuse_new(fuse_channel, &fuse_arguments, &fuse_ops, sizeof(fuse_ops), NULL); if (fuse_handle == NULL){ qfError()<<"fuse_new() failed"; exit(1); } if(dbfs_drv) { #ifdef USE_QT_EVENT_LOOP qfInfo() << "Using Qt event loop with FUSE in separated thread"; TheApp *app = new TheApp(argc, argv); s_fuseThread = new FuseThread(fuse_handle, fuse_channel, QString::fromUtf8(mount_point)); dbfs_drv->moveToThread(s_fuseThread); QObject::connect(s_fuseThread, &QThread::finished, app, &TheApp::onFuseThreadFinished, Qt::QueuedConnection); s_fuseThread->start(); set_signal_handlers(); { /// setup SQL notify QSqlDatabase notify_db = QSqlDatabase::addDatabase("QPSQL", "DBFS_Notify"); notify_db.setHostName(db_connection.hostName()); notify_db.setPort(db_connection.port()); notify_db.setUserName(db_connection.userName()); notify_db.setPassword(db_connection.password()); notify_db.setDatabaseName(db_connection.databaseName()); bool ok = notify_db.open(); if(!ok) { qfError() << "Error connect DBFS notify connection" << notify_db.lastError().text(); } else { QSqlDriver *drv = notify_db.driver(); //qRegisterMetaType<QSqlDriver::NotificationSource>("QSqlDriver::NotificationSource"); QObject::connect(drv, SIGNAL(notification(QString,QSqlDriver::NotificationSource,QVariant)), dbfs_drv, SLOT(onSqlNotify(QString,QSqlDriver::NotificationSource,QVariant)), Qt::DirectConnection); //QObject::connect(drv, SIGNAL(notification(QString,QSqlDriver::NotificationSource,QVariant)), app, SLOT(onSqlNotify(QString,QSqlDriver::NotificationSource,QVariant))); drv->subscribeToNotification(qfs::DbFsDriver::CHANNEL_INVALIDATE_DBFS_DRIVER_CACHE); qfInfo() << drv << "subscribedToNotifications:" << drv->subscribedToNotifications().join(", "); } } app->exec(); qfInfo() << "Waiting for FUSE thread to join ..."; s_fuseThread->wait(); #else qfInfo() << "Using FUSE event loop"; fuse_loop(fuse_handle); qfInfo() << "FUSE has quit its event loop"; #endif qfsqldbfs_setdriver(nullptr); QF_SAFE_DELETE(dbfs_drv); #ifdef USE_QT_EVENT_LOOP QF_SAFE_DELETE(s_fuseThread); QF_SAFE_DELETE(app); #endif } else { // used just to print FUSE help fuse_loop(fuse_handle); } qfInfo() << "bye"; return 0; }
void RacomClient::stop() { Super::stop(); QF_SAFE_DELETE(m_udpSocket); }
void RacomClient::stop() { Super::stop(); QF_SAFE_DELETE(m_rawSIDataUdpSocket); }
ItemDelegate::~ItemDelegate() { //QF_SAFE_DELETE(m_creator); The factory takes ownership of the item editor QF_SAFE_DELETE(m_factory); }
/* static Receipts::ReceiptsPlugin *receiptsPlugin() { qff::MainWindow *fwk = qff::MainWindow::frameWork(); auto *ret = qobject_cast<Receipts::ReceiptsPlugin *>(fwk->plugin("Receipts")); QF_ASSERT(ret != nullptr, "Bad plugin", return 0); return ret; } */ void ReceiptsPrinter::printReceipt(const QString &report_file_name, const QVariantMap &report_data) { qfLogFuncFrame(); QF_TIME_SCOPE("ReceiptsPrinter::printReceipt()"); const ReceiptsPrinterOptions &printer_opts = m_printerOptions; QPrinter *printer = nullptr; QPaintDevice *paint_device = nullptr; if(printer_opts.printerType() == (int)ReceiptsPrinterOptions::PrinterType::GraphicPrinter) { QF_TIME_SCOPE("init graphics printer"); QPrinterInfo pi = QPrinterInfo::printerInfo(printer_opts.graphicsPrinterName()); if(pi.isNull()) { for(auto s : QPrinterInfo::availablePrinterNames()) { qfInfo() << "available printer:" << s; } pi = QPrinterInfo::defaultPrinter(); } if(pi.isNull()) { qfWarning() << "Default printer not set"; return; } qfInfo() << "printing on:" << pi.printerName(); printer = new QPrinter(pi); paint_device = printer; } else { qfInfo() << "printing on:" << printer_opts.characterPrinterModel() << "at:" << printer_opts.characterPrinterDevice(); qff::MainWindow *fwk = qff::MainWindow::frameWork(); paint_device = fwk; } qf::qmlwidgets::reports::ReportProcessor rp(paint_device); { QF_TIME_SCOPE("setting report and data"); rp.setReport(report_file_name); for(auto key : report_data.keys()) { rp.setTableData(key, report_data.value(key)); } } if(printer_opts.printerType() == (int)ReceiptsPrinterOptions::PrinterType::GraphicPrinter) { QF_TIME_SCOPE("process graphics"); { QF_TIME_SCOPE("process report"); rp.process(); } qf::qmlwidgets::reports::ReportItemMetaPaintReport *doc; { QF_TIME_SCOPE("getting processor output"); doc = rp.processorOutput(); } qf::qmlwidgets::reports::ReportItemMetaPaint *it = doc->child(0); if(it) { QF_TIME_SCOPE("draw meta-paint"); qf::qmlwidgets::reports::ReportPainter painter(paint_device); painter.drawMetaPaint(it); } QF_SAFE_DELETE(printer); } else if(printer_opts.printerType() == (int)ReceiptsPrinterOptions::PrinterType::CharacterPrinter) { QDomDocument doc; doc.setContent(QLatin1String("<?xml version=\"1.0\"?><report><body/></report>")); QDomElement el_body = doc.documentElement().firstChildElement("body"); qf::qmlwidgets::reports::ReportProcessor::HtmlExportOptions opts; opts.setConvertBandsToTables(false); rp.processHtml(el_body, opts); //qfInfo() << doc.toString(); QList<QByteArray> data_lines = createPrinterData(el_body, printer_opts); auto save_file = [data_lines](const QString &fn) { QFile f(fn); if(f.open(QFile::WriteOnly)) { for(QByteArray ba : data_lines) { f.write(ba); f.write("\n"); } } else { qfError() << "Cannot open file" << f.fileName() << "for writing!"; } }; if(!printer_opts.characterPrinterDirectory().isEmpty()) { QString fn = printer_opts.characterPrinterDirectory(); qf::core::utils::FileUtils::ensurePath(fn); QCryptographicHash ch(QCryptographicHash::Sha1); for(QByteArray ba : data_lines) ch.addData(ba); fn += '/' + QString::fromLatin1(ch.result().toHex().mid(0, 8)) + ".txt"; save_file(fn); } else if (!printer_opts.characterPrinterDevice().isEmpty()) { save_file(printer_opts.characterPrinterDevice()); } } }