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());
}
}
}
