@esslassi/electron-printer 0.0.3 → 0.0.5

package/src/mac_printer.cpp

@@ -0,0 +1,166 @@
+#include "mac_printer.h"
+#include <cups/cups.h>
+
+std::string MacPrinter::GetPrinterStatus(ipp_pstate_t state)
+{
+    switch (state)
+    {
+    case IPP_PRINTER_IDLE:
+        return "ready";
+    case IPP_PRINTER_PROCESSING:
+        return "printing";
+    case IPP_PRINTER_STOPPED:
+        return "stopped";
+    default:
+        return "unknown";
+    }
+}
+
+PrinterInfo MacPrinter::GetPrinterDetails(const std::string &printerName, bool isDefault)
+{
+    PrinterInfo info;
+    info.name = printerName;
+    info.isDefault = isDefault;
+
+    cups_dest_t *dests;
+    int num_dests = cupsGetDests(&dests);
+    cups_dest_t *dest = cupsGetDest(printerName.c_str(), NULL, num_dests, dests);
+
+    if (dest != NULL)
+    {
+        for (int i = 0; i < dest->num_options; i++)
+        {
+            info.details[dest->options[i].name] = dest->options[i].value;
+        }
+
+        http_t *http = httpConnect2(cupsServer(), ippPort(), NULL, AF_UNSPEC,
+                                  HTTP_ENCRYPTION_IF_REQUESTED, 1, 30000, NULL);
+        if (http != NULL)
+        {
+            ipp_t *request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
+            
+            char uri[HTTP_MAX_URI];
+            httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
+                           "localhost", 0, "/printers/%s", printerName.c_str());
+
+            ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                        "printer-uri", NULL, uri);
+
+            ipp_t *response = cupsDoRequest(http, request, "/");
+            if (response != NULL)
+            {
+                ipp_attribute_t *attr = ippFindAttribute(response,
+                                                       "printer-state", IPP_TAG_ENUM);
+                if (attr != NULL)
+                {
+                    info.status = GetPrinterStatus((ipp_pstate_t)ippGetInteger(attr, 0));
+                }
+
+                attr = ippFindAttribute(response, "printer-location", IPP_TAG_TEXT);
+                if (attr != NULL)
+                    info.details["location"] = ippGetString(attr, 0, NULL);
+
+                attr = ippFindAttribute(response, "printer-info", IPP_TAG_TEXT);
+                if (attr != NULL)
+                    info.details["comment"] = ippGetString(attr, 0, NULL);
+
+                attr = ippFindAttribute(response, "printer-make-and-model", IPP_TAG_TEXT);
+                if (attr != NULL)
+                    info.details["driver"] = ippGetString(attr, 0, NULL);
+
+                ippDelete(response);
+            }
+            httpClose(http);
+        }
+    }
+    cupsFreeDests(num_dests, dests);
+    return info;
+}
+
+std::vector<PrinterInfo> MacPrinter::GetPrinters()
+{
+    std::vector<PrinterInfo> printers;
+    cups_dest_t *dests;
+    int num_dests = cupsGetDests(&dests);
+
+    for (int i = 0; i < num_dests; i++)
+    {
+        printers.push_back(GetPrinterDetails(dests[i].name, dests[i].is_default));
+    }
+
+    cupsFreeDests(num_dests, dests);
+    return printers;
+}
+
+PrinterInfo MacPrinter::GetSystemDefaultPrinter()
+{
+    cups_dest_t *dests;
+    int num_dests = cupsGetDests(&dests);
+    cups_dest_t *dest = cupsGetDest(NULL, NULL, num_dests, dests);
+
+    PrinterInfo printer;
+    if (dest != NULL)
+    {
+        printer = GetPrinterDetails(dest->name, true);
+    }
+
+    cupsFreeDests(num_dests, dests);
+    return printer;
+}
+
+bool MacPrinter::PrintDirect(const std::string &printerName,
+                           const std::vector<uint8_t> &data,
+                           const std::string &dataType)
+{
+    int jobId = cupsCreateJob(CUPS_HTTP_DEFAULT, printerName.c_str(),
+                            "Node.js Print Job", 0, NULL);
+
+    if (jobId <= 0)
+        return false;
+
+    http_status_t status = cupsStartDocument(CUPS_HTTP_DEFAULT, printerName.c_str(),
+                                           jobId, "Node.js Print Job",
+                                           dataType.c_str(), 1);
+
+    if (status != HTTP_STATUS_CONTINUE)
+    {
+        cupsCancelJob(printerName.c_str(), jobId);
+        return false;
+    }
+
+    if (cupsWriteRequestData(CUPS_HTTP_DEFAULT,
+                           reinterpret_cast<const char *>(data.data()),
+                           data.size()) != HTTP_STATUS_CONTINUE)
+    {
+        cupsCancelJob(printerName.c_str(), jobId);
+        return false;
+    }
+
+    status = static_cast<http_status_t>(cupsFinishDocument(CUPS_HTTP_DEFAULT, printerName.c_str()));
+    return status == HTTP_STATUS_OK;
+}
+
+PrinterInfo MacPrinter::GetStatusPrinter(const std::string &printerName)
+{
+    cups_dest_t *dests;
+    int num_dests = cupsGetDests(&dests);
+
+    cups_dest_t *defaultDest = cupsGetDest(NULL, NULL, num_dests, dests);
+    bool isDefault = false;
+
+    if (defaultDest != NULL)
+    {
+        isDefault = (printerName == defaultDest->name);
+    }
+
+    cups_dest_t *dest = cupsGetDest(printerName.c_str(), NULL, num_dests, dests);
+    PrinterInfo printer;
+
+    if (dest != NULL)
+    {
+        printer = GetPrinterDetails(printerName, isDefault);
+    }
+
+    cupsFreeDests(num_dests, dests);
+    return printer;
+} 

package/src/mac_printer.h

@@ -0,0 +1,22 @@
+#ifndef MAC_PRINTER_H
+#define MAC_PRINTER_H
+
+#include <cups/cups.h>
+#include <cups/ppd.h>
+#include <cstdint>
+#include "printer_interface.h"
+
+class MacPrinter : public PrinterInterface
+{
+private:
+    std::string GetPrinterStatus(ipp_pstate_t state);
+
+public:
+    virtual PrinterInfo GetPrinterDetails(const std::string &printerName, bool isDefault = false) override;
+    virtual std::vector<PrinterInfo> GetPrinters() override;
+    virtual PrinterInfo GetSystemDefaultPrinter() override;
+    virtual bool PrintDirect(const std::string &printerName, const std::vector<uint8_t> &data, const std::string &dataType) override;
+    virtual PrinterInfo GetStatusPrinter(const std::string &printerName) override;
+};
+
+#endif 

package/src/main.cpp

@@ -0,0 +1,22 @@
+#include <napi.h>
+#include "printer_factory.h"
+
+Napi::Value PrintDirect(const Napi::CallbackInfo &info);
+Napi::Value GetPrinters(const Napi::CallbackInfo &info);
+Napi::Value GetSystemDefaultPrinter(const Napi::CallbackInfo &info);
+Napi::Value GetStatusPrinter(const Napi::CallbackInfo &info);
+
+Napi::Object Init(Napi::Env env, Napi::Object exports)
+{
+    exports.Set(Napi::String::New(env, "printDirect"),
+                Napi::Function::New(env, PrintDirect));
+    exports.Set(Napi::String::New(env, "getPrinters"),
+                Napi::Function::New(env, GetPrinters));
+    exports.Set(Napi::String::New(env, "getDefaultPrinter"),
+                Napi::Function::New(env, GetSystemDefaultPrinter));
+    exports.Set(Napi::String::New(env, "getStatusPrinter"),
+                Napi::Function::New(env, GetStatusPrinter));
+    return exports;
+}
+
+NODE_API_MODULE(electron_printer, Init)

package/src/print.cpp

@@ -0,0 +1,272 @@
+#include <napi.h>
+#include "printer_factory.h"
+
+class PrinterWorker : public Napi::AsyncWorker
+{
+private:
+    std::unique_ptr<PrinterInterface> printer;
+    std::function<void(PrinterWorker *)> work;
+    PrinterInfo printerResult;
+    std::vector<PrinterInfo> printersResult;
+    bool isMultiplePrinters;
+    bool success;
+
+public:
+    PrinterWorker(Napi::Function &callback, std::function<void(PrinterWorker *)> executeWork)
+        : Napi::AsyncWorker(callback),
+          work(executeWork),
+          isMultiplePrinters(false),
+          success(false)
+    {
+        printer = PrinterFactory::Create();
+    }
+
+    void Execute() override
+    {
+        if (printer)
+        {
+            work(this);
+        }
+        else
+        {
+            SetError("Failed to create printer");
+        }
+    }
+
+    void OnOK() override
+    {
+        Napi::Env env = Env();
+        Napi::HandleScope scope(env);
+
+        if (isMultiplePrinters)
+        {
+            Napi::Array result = Napi::Array::New(env, printersResult.size());
+            for (size_t i = 0; i < printersResult.size(); i++)
+            {
+                result.Set(i, CreatePrinterObject(env, printersResult[i]));
+            }
+            Callback().Call({env.Null(), result});
+        }
+        else
+        {
+            Callback().Call({env.Null(), CreatePrinterObject(env, printerResult)});
+        }
+    }
+
+    PrinterInterface *GetPrinter() { return printer.get(); }
+    void SetPrinterResult(const PrinterInfo &result) { printerResult = result; }
+    void SetPrintersResult(const std::vector<PrinterInfo> &result)
+    {
+        printersResult = result;
+        isMultiplePrinters = true;
+    }
+    void SetSuccess(bool value) { success = value; }
+    bool GetSuccess() const { return success; }
+
+private:
+    Napi::Object CreatePrinterObject(Napi::Env env, const PrinterInfo &printer)
+    {
+        Napi::Object result = Napi::Object::New(env);
+        result.Set("name", printer.name);
+        result.Set("status", printer.status);
+
+        // Só incluir estes campos se NÃO for um resultado do PrintDirect
+        if (!success)
+        { // Se success for true, é um PrintDirect
+            result.Set("isDefault", printer.isDefault);
+
+            Napi::Object details = Napi::Object::New(env);
+            for (const auto &detail : printer.details)
+            {
+                details.Set(detail.first, detail.second);
+            }
+            result.Set("details", details);
+        }
+
+        return result;
+    }
+};
+
+Napi::Value PrintDirect(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1 || !info[0].IsObject())
+    {
+        Napi::TypeError::New(env, "Expected an object as argument").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    Napi::Object options = info[0].As<Napi::Object>();
+
+    if (!options.Has("printerName") || !options.Has("data"))
+    {
+        Napi::TypeError::New(env, "Object must have 'printerName' and 'data' properties").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    if (!options.Get("printerName").IsString())
+    {
+        Napi::TypeError::New(env, "printerName must be a string").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    Napi::Value data = options.Get("data");
+    if (!data.IsString() && !data.IsBuffer())
+    {
+        Napi::TypeError::New(env, "data must be a string or Buffer").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    std::string printerName = options.Get("printerName").As<Napi::String>().Utf8Value();
+    std::vector<uint8_t> printData;
+
+    if (data.IsString())
+    {
+        std::string strData = data.As<Napi::String>().Utf8Value();
+        printData.assign(strData.begin(), strData.end());
+    }
+    else
+    {
+        Napi::Buffer<uint8_t> buffer = data.As<Napi::Buffer<uint8_t>>();
+        printData.assign(buffer.Data(), buffer.Data() + buffer.Length());
+    }
+
+    std::string dataType = "RAW";
+    if (options.Has("dataType") && options.Get("dataType").IsString())
+    {
+        dataType = options.Get("dataType").As<Napi::String>().Utf8Value();
+    }
+
+    Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
+
+    auto callback = Napi::Function::New(env, [deferred](const Napi::CallbackInfo &info)
+                                        {
+        if (info[0].IsNull()) {
+            deferred.Resolve(info[1]);
+        } else {
+            deferred.Reject(info[0].As<Napi::Error>().Value());
+        }
+        return info.Env().Undefined(); });
+
+    auto worker = new PrinterWorker(
+        callback,
+        [printerName, printData, dataType](PrinterWorker *worker)
+        {
+            bool success = worker->GetPrinter()->PrintDirect(printerName, printData, dataType);
+            worker->SetSuccess(true); // Indica que é um resultado do PrintDirect
+            PrinterInfo result;
+            result.name = printerName;
+            result.status = success ? "success" : "failed";
+            worker->SetPrinterResult(result);
+        });
+
+    worker->Queue();
+    return deferred.Promise();
+}
+
+Napi::Value GetPrinters(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
+
+    auto callback = Napi::Function::New(env, [deferred](const Napi::CallbackInfo &info)
+                                        {
+        if (info[0].IsNull()) {
+            deferred.Resolve(info[1]);
+        } else {
+            deferred.Reject(info[0].As<Napi::Error>().Value());
+        }
+        return info.Env().Undefined(); });
+
+    auto worker = new PrinterWorker(
+        callback,
+        [](PrinterWorker *worker)
+        {
+            auto printers = worker->GetPrinter()->GetPrinters();
+            worker->SetPrintersResult(printers);
+        });
+
+    worker->Queue();
+    return deferred.Promise();
+}
+
+Napi::Value GetSystemDefaultPrinter(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
+
+    auto callback = Napi::Function::New(env, [deferred](const Napi::CallbackInfo &info)
+                                        {
+        if (info[0].IsNull()) {
+            deferred.Resolve(info[1]);
+        } else {
+            deferred.Reject(info[0].As<Napi::Error>().Value());
+        }
+        return info.Env().Undefined(); });
+
+    auto worker = new PrinterWorker(
+        callback,
+        [](PrinterWorker *worker)
+        {
+            auto printer = worker->GetPrinter()->GetSystemDefaultPrinter();
+            worker->SetPrinterResult(printer);
+        });
+
+    worker->Queue();
+    return deferred.Promise();
+}
+
+Napi::Value GetStatusPrinter(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1 || !info[0].IsObject())
+    {
+        Napi::TypeError::New(env, "Expected an object as argument").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    Napi::Object options = info[0].As<Napi::Object>();
+
+    Napi::Array propertyNames = options.GetPropertyNames();
+    for (uint32_t i = 0; i < propertyNames.Length(); i++)
+    {
+        propertyNames.Get(i).As<Napi::String>();
+    }
+
+    if (!options.Has("printerName"))
+    {
+        Napi::TypeError::New(env, "Object must have 'printerName' property").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    if (!options.Get("printerName").IsString())
+    {
+        Napi::TypeError::New(env, "printerName must be a string").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    std::string printerName = options.Get("printerName").As<Napi::String>().Utf8Value();
+    Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
+
+    auto callback = Napi::Function::New(env, [deferred](const Napi::CallbackInfo &info)
+                                        {
+        if (info[0].IsNull()) {
+            deferred.Resolve(info[1]);
+        } else {
+            deferred.Reject(info[0].As<Napi::Error>().Value());
+        }
+        return info.Env().Undefined(); });
+
+    auto worker = new PrinterWorker(
+        callback,
+        [printerName](PrinterWorker *worker)
+        {
+            auto printer = worker->GetPrinter()->GetStatusPrinter(printerName);
+            worker->SetPrinterResult(printer);
+        });
+
+    worker->Queue();
+    return deferred.Promise();
+}

package/src/printer_factory.cpp

@@ -0,0 +1,20 @@
+#include "printer_factory.h"
+
+#ifdef _WIN32
+#include "windows_printer.h"
+#elif defined(__APPLE__)
+#include "mac_printer.h"
+#else
+#include "linux_printer.h"
+#endif
+
+std::unique_ptr<PrinterInterface> PrinterFactory::Create()
+{
+#ifdef _WIN32
+    return std::make_unique<WindowsPrinter>();
+#elif defined(__APPLE__)
+    return std::make_unique<MacPrinter>();
+#else
+    return std::make_unique<LinuxPrinter>();
+#endif
+}

package/src/printer_factory.h

@@ -0,0 +1,13 @@
+#ifndef PRINTER_FACTORY_H
+#define PRINTER_FACTORY_H
+
+#include "printer_interface.h"
+#include <memory>
+
+class PrinterFactory
+{
+public:
+    static std::unique_ptr<PrinterInterface> Create();
+};
+
+#endif

package/src/printer_interface.h

@@ -0,0 +1,29 @@
+#ifndef PRINTER_INTERFACE_H
+#define PRINTER_INTERFACE_H
+
+#include <string>
+#include <vector>
+#include <map>
+#include <cstdint>
+
+struct PrinterInfo
+{
+    std::string name;
+    bool isDefault;
+    std::map<std::string, std::string> details;
+    std::string status;
+};
+
+class PrinterInterface
+{
+public:
+    virtual ~PrinterInterface() = default;
+
+    virtual PrinterInfo GetPrinterDetails(const std::string &printerName, bool isDefault = false) = 0;
+    virtual std::vector<PrinterInfo> GetPrinters() = 0;
+    virtual PrinterInfo GetSystemDefaultPrinter() = 0;
+    virtual bool PrintDirect(const std::string &printerName, const std::vector<uint8_t> &data, const std::string &dataType) = 0;
+    virtual PrinterInfo GetStatusPrinter(const std::string &printerName) = 0;
+};
+
+#endif