def clearJobsQueue():
printer = win32print.OpenPrinter('PDFCreator')
jobs = win32print.EnumJobs(printer, 0, 100, 2)
while len(jobs) > 0:
for currentJob in jobs:
print '\nDeleting print job with id [' + str(currentJob['JobId']) + ']'
win32print.SetJob(printer, currentJob['JobId'], 0, None, win32print.JOB_CONTROL_DELETE)
win32print.ClosePrinter(printer)
time.sleep(.5)
printer = win32print.OpenPrinter('PDFCreator')
jobs = win32print.EnumJobs(printer, 0, 100, 2)
win32print.ClosePrinter(printer)
def do(filename):
filename = filename.read()
# word wrap the log, so that it completely is on page
formatted_log = '\r\n'.join(textwrap.wrap(filename, width=75, replace_whitespace=False))
if platform.system() == 'Windows': # if we are on windows, print via this section
import sys
import win32print # as this module is only available under windows, import it here to prevent errors
printer_name = win32print.GetDefaultPrinter()
#
# raw_data could equally be raw PCL/PS read from
# some print-to-file operation
#
if sys.version_info >= (3,):
raw_data = bytes(formatted_log)
else:
raw_data = formatted_log
h_printer = win32print.OpenPrinter(printer_name)
try:
_ = win32print.StartDocPrinter(h_printer, 1, ("Log File Printout", None, "RAW"))
try:
win32print.StartPagePrinter(h_printer)
win32print.WritePrinter(h_printer, raw_data)
win32print.EndPagePrinter(h_printer)
finally:
win32print.EndDocPrinter(h_printer)
finally:
win32print.ClosePrinter(h_printer)
else: # if we are on a unix-like, print via this section
import subprocess
lpr = subprocess.Popen("/usr/bin/lpr", stdin=subprocess.PIPE)
lpr.stdin.write(formatted_log)
def printPdf(selPrt, pdfFN, paperForm, numCopies):
#Save the current default Printer
dfltPrt = win32print.GetDefaultPrinter()
win32print.SetDefaultPrinter(selPrt)
#reportStat('====>> DefaultPrinter: {}'.format( win32print.GetDefaultPrinter()), None)
handle, level, prtProperties = prepPrinter(selPrt)
setXeroxAttr(prtProperties, paperForm, numCopies)
#createDC(dfltPrt, prtProperties['pDevMode'])
## 'SetPrinter' fails because of 'Access is denied.'
## But the attribute 'Duplex' is set correctly
#try:
win32print.SetPrinter(handle, level, prtProperties, 0)
#except:
# #reportStat("win32print.SetPrinter: set 'Duplex'", None)
# pass
#cfgPrt(selPrt)
res = win32api.ShellExecute(0, 'print', pdfFN, None, '.', 0)
win32print.ClosePrinter(handle)
handle, level, prtProperties = prepPrinter(selPrt)
showpDevMode(prtProperties)
#Restore the current default Printer
win32print.SetDefaultPrinter(dfltPrt)
def print_raw_win32print(content, printer_name, job_description):
""" Start a print job and send raw data to the printer.
Args:
content: The raw data to print.
printer_name: The printer's name.
job_description: A description of the job.
Returns:
None
References:
* http://timgolden.me.uk/python/win32_how_do_i/print.html
* http://timgolden.me.uk/pywin32-docs/win32print.html
Even Tim Golden recommends just calling `print <filename> /d:<printer>` on the shell.
* https://docs.microsoft.com/en-us/windows/win32/printdocs/using-the-printing-functions
(For C++ applications).
* http://www.icodeguru.com/WebServer/Python-Programming-on-Win32/ch10.htm
"""
import win32print
p = win32print.OpenPrinter(printer_name)
job = win32print.StartDocPrinter(p, 1, (job_description, None, "RAW"))
win32print.StartPagePrinter(p)
win32print.WritePrinter(p, content)
win32print.EndPagePrinter(p)
win32print.EndDocPrinter(p)
win32print.ClosePrinter(p)
def print_job_checker():
server = socket.gethostname()
while True:
jobs = []
for p in win32print.EnumPrinters(win32print.PRINTER_ENUM_LOCAL, None,
1):
flags, desc, name, comment = p
phandle = win32print.OpenPrinter(name)
print_jobs = win32print.EnumJobs(phandle, 0, -1, 1)
if print_jobs:
jobs.extend(list(print_jobs))
for job in print_jobs:
document = job["pDocument"]
username = job['pUserName']
identity = job['JobId']
jobstate = job['Status']
machinename = job['pMachineName'].replace("\\\\", "")
pTime = datetime.datetime.now().isoformat()
today = datetime.date.today().isoformat()
Pages = job['TotalPages']
printstr = "[Server:" + server + "],[Who:" + username + "],[Computer:" + machinename + "],[Print Time:" + pTime + "],[JobID:" + str(
identity) + "]"
print(printstr)
win32print.ClosePrinter(phandle)
time.sleep(0.5)
def GetJobList(self, printer):
phandle = win32print.OpenPrinter(printer)
#now get all the print jobs (start at job 0 and -1 for all jobs)
jlist = win32print.EnumJobs(phandle, 0, -1, 1)
win32print.ClosePrinter(phandle)
return jlist # this lists all jobs on all printers
def printer1(self, img): #调用打印机，请事先把默认打印机，纸张格式等参数从电脑上调好
print('start print ' + img)
printer_name = win32print.GetDefaultPrinter()
#
# raw_data could equally be raw PCL/PS read from
# some print-to-file operation
#
if sys.version_info >= (3, ):
raw_data = bytes(a, "utf-8")
else:
raw_data = "This is a test"
hPrinter = win32print.OpenPrinter(printer_name)
try:
hJob = win32print.StartDocPrinter(hPrinter, 1, (img, None, "RAW"))
print('here1' + img)
try:
win32print.StartPagePrinter(hPrinter)
win32print.WritePrinter(hPrinter, raw_data)
win32print.EndPagePrinter(hPrinter)
print('here2')
finally:
win32print.EndDocPrinter(hPrinter)
print('here3')
finally:
win32print.ClosePrinter(hPrinter)
print('here4')
def thermalPrinter(base64code):
try:
raw_str = str(base64code)
raw_base = base64.b64decode(raw_str)
data = bytes(raw_base)
nameprinter = win32print.GetDefaultPrinter()
hPrinter = win32print.OpenPrinter(nameprinter)
win32print.StartDocPrinter(hPrinter, 1, ("Print data otros pagos", None, "RAW"))
try:
win32print.StartPagePrinter(hPrinter)
win32print.WritePrinter(hPrinter, data)
win32print.EndPagePrinter(hPrinter)
win32print.EndDocPrinter(hPrinter)
win32print.ClosePrinter(hPrinter)
except Exception as e:
return jsonify({
"code":500,
"message":str(e.message)
})
except Exception as e:
return jsonify({
"code":500,
"message":str(e.message)
})
return jsonify({
"code":200,
"message":"printer!!!"
})
def print_document(filename, printer_name):
print(printer_name)
# printer_name = win32print.GetDefaultPrinter()
if sys.version_info >= (3, ):
fp = open("./static/UPLOADFOLDER/" + filename, "rb")
raw_data = bytes("This is a test", "utf-8")
else:
fp = open("./static/UPLOADFOLDER/" + filename, "r")
raw_data = "This is a test"
data = fp.read()
print(printer_name)
hPrinter = win32print.OpenPrinter(printer_name)
try:
hJob = win32print.StartDocPrinter(hPrinter, 1, (filename, None, "RAW"))
try:
jobInfo = win32print.GetJob(hPrinter, hJob, 1)
win32print.SetJob(hPrinter, hJob, 1, jobInfo,
win32print.JOB_CONTROL_SENT_TO_PRINTER)
win32print.StartPagePrinter(hPrinter)
win32print.WritePrinter(hPrinter, data)
win32print.EndPagePrinter(hPrinter)
finally:
win32print.EndDocPrinter(hPrinter)
finally:
win32print.ClosePrinter(hPrinter)
# os.startfile("H:/Projects/College/LanPrint/static/UPLOADFOLDER/"+filename, "print")
return Response("Printing Document", status=200, mimetype='text/plain')
def printer(raw_data):
default_printer = win32print.GetDefaultPrinter()
h = win32print.OpenPrinter(default_printer)
win32print.StartDocPrinter(h, 1, ("", "", "RAW"))
win32print.WritePrinter(h, raw_data)
win32print.EndDocPrinter(h)
win32print.ClosePrinter(h)
def close(self):
if not self.hPrinter:
return
win32print.EndPagePrinter(self.hPrinter)
win32print.EndDocPrinter(self.hPrinter)
win32print.ClosePrinter(self.hPrinter)
self.hPrinter = None
def info():
texto_a_imprimir = self.texto.get("1.0", "end")
if self.ruta != "":
direccion = self.ruta.split("/")[-1]
nombre_archivo = tempfile.mktemp("_{}".format(direccion))
else:
nombre_archivo = tempfile.mktemp(".txt")
fichero = open(nombre_archivo, "w")
fichero.write(texto_a_imprimir)
if sys.version_info >= (3, ):
raw_data = bytes(nombre_archivo, "utf-8")
else:
raw_data = nombre_archivo
hPrinter = win32print.OpenPrinter(
combo_lista_impr.selection_get())
try:
hJob = win32print.StartDocPrinter(
hPrinter, 1, (nombre_archivo, None, "RAW"))
try:
win32api.ShellExecute(0, "print", nombre_archivo, None,
".", 0)
win32print.StartPagePrinter(hPrinter)
win32print.WritePrinter(hPrinter, raw_data)
win32print.EndPagePrinter(hPrinter)
finally:
win32print.EndDocPrinter(hPrinter)
finally:
win32print.ClosePrinter(hPrinter)
fichero.close()
def SendToBP33(fn_bpl, req_confirm = True):
printers = win32print.EnumPrinters(2)
for p in printers:
if p[3] == 'BBP33':
printer_name = p[2]
#print('Found printer ' + printer_name)
if (printer_name):
cont = 'y'
if(req_confirm):
cont = input('Use ' + printer_name + ' to print labels? [y/n]\n')
if (cont == 'y'):
f_bpl = open(fn_bpl, "rb")
hPrinter = win32print.OpenPrinter(printer_name)
try:
hJob = win32print.StartDocPrinter (hPrinter, 1, ("Cable labels", None, "RAW"))
try:
win32print.StartPagePrinter (hPrinter)
win32print.WritePrinter (hPrinter, f_bpl.read())
win32print.EndPagePrinter (hPrinter)
finally:
win32print.EndDocPrinter (hPrinter)
finally:
win32print.ClosePrinter (hPrinter)
f_bpl.close()
else:
def ImprimirArquivo(numeroPedido,
event=None): #Função para Imprimir o Pedido
try:
# Definindo o caminho do arquivo para impressão
arquivo = "C:/Users/Itamar/Documents/GitHub/Sistema-Scripts/pedidos/Pedido" + str(
numeroPedido) + '.txt'
_printer = StringVar(Pedidos_window)
# Setando a impressora padrão do windows
_printer.set(win32print.GetDefaultPrinter())
#print(_printer)
PRINTER_DEFAULTS = {"DesiredAccess": win32print.PRINTER_ALL_ACCESS}
pHandle = win32print.OpenPrinter(_printer.get(), PRINTER_DEFAULTS)
properties = win32print.GetPrinter(pHandle, 2)
win32print.SetPrinter(pHandle, 2, properties, 0)
try:
#win32print.SetDefaultPrinter(_printer.get())
win32api.ShellExecute(0, "print", arquivo, None, ".", 0)
win32print.ClosePrinter(pHandle)
except:
pass
messagebox.showerror("Error",
"Não foi passivel imprimir o pedido.")
except:
pass
messagebox.showerror("Error",
"Não foi passivel imprimir o pedido.")
def getJobDetail(printer, id):
printer_handle = win32print.OpenPrinter(printer)
job_detail = win32print.GetJob(printer_handle, id, 2)
win32print.ClosePrinter(printer_handle)
return job_detail
def GetJobList(printer):
printer_handle = win32print.OpenPrinter(printer)
job_list = win32print.EnumJobs(printer_handle, 0, -1, 2)
win32print.ClosePrinter(printer_handle)
return job_list
def EnumPrinter(self):
handle = win32print.OpenPrinter(self.printer_name)
win32print.GetPrinter(handle)
win32print.ClosePrinter(handle)
printers = []
for p in win32print.EnumPrinters(2):
printers.append(p[1].split(',')[0])
return printers
def close(self):
p = self.printer
win32print.EndPagePrinter(p)
win32print.EndDocPrinter(p)
win32print.ClosePrinter(p)
#: Sync
self.transport.connected = False
self.transport.protocol.connection_lost()
def print_document(self, document):
raw_data = document.cut_if_uncut().encoded
win_printer = win32print.GetDefaultPrinter()
printer = win32print.OpenPrinter(win_printer)
win32print.StartDocPrinter(printer, 1, ('CASHDRAWERPRINT', None, None))
win32print.WritePrinter(printer, raw_data)
win32print.EndDocPrinter(printer)
win32print.ClosePrinter(printer)
def get_printer_info(name):
printer = win32print.OpenPrinter(name)
try:
printer_info = win32print.GetPrinter(printer)
finally:
win32print.ClosePrinter(printer)
return printer_info
def printer(raw_data):
hPrinter = win32print.OpenPrinter(printer_name)
hJob = win32print.StartDocPrinter(hPrinter, 1,
("test of raw data", None, "RAW"))
win32print.StartPagePrinter(hPrinter)
win32print.WritePrinter(hPrinter, raw_data)
win32print.EndPagePrinter(hPrinter)
win32print.EndDocPrinter(hPrinter)
win32print.ClosePrinter(hPrinter)
def printCobrar(self):
printFinal = ''
qsFinal = self.request.data.get('qsFinal')
qsTotal = self.request.data.get('qsTotal')
folio = self.request.data.get('folio')
mesero = self.request.data.get('mesero')
mesa = self.request.data.get('mesa')
qsFinal.pop(0)
for orden in qsFinal:
for platillo in orden:
_platillo = platillo.get('platillo')
if 'B-' in _platillo:
_platillo = 'Bebida {0}'.format(
platillo.get('platillo').split('-')[1])
elif 'Q-' in _platillo:
_platillo = 'Quesadilla {0}'.format(
platillo.get('platillo').split('-')[1])
printFinal += '\n{0} {1} \n\t\t\t\t ${2}'.format(
platillo.get('cantidad'), _platillo,
platillo.get('precio'))
print_final_caja = """
\t FOLIO: {folio}
MIXTAS EL COSTEÑO
Mesero: {mesero}
Mesa # {mesa}
\r ----------------
Ordenes:
{printFinal}
\t\t\t---- \t
\t\t\t $ {total} \t
\n\tDesarollado por TEAM-ANYOAN\n\t [email protected]
""".format(folio=folio,
mesero=mesero,
mesa=mesa,
printFinal=printFinal,
total=qsTotal)
# Epson Bebidas y Caja
printer = win32print.OpenPrinter('EPSON TM-T88V 1')
jid = win32print.StartDocPrinter(printer, 1, ('TEST DOC', None, 'RAW'))
bytes = win32print.WritePrinter(printer, print_final_caja)
win32print.EndDocPrinter(printer)
win32print.ClosePrinter(printer)
# Cortar
hDC = win32ui.CreateDC()
hDC.CreatePrinterDC('EPSON TM-T88V 1')
hDC.StartDoc("Test doc")
hDC.StartPage()
hDC.EndPage()
hDC.EndDoc()
def winPrint(text, name):
import win32print #is this how I multiplatform?
pname = win32print.GetDefaultPrinter()
printer = win32print.OpenPrinter(pname)
job = win32print.StartDocPrinter(printer, 1, (name, None, "RAW"))
win32print.StartPagePrinter(printer)
win32print.WritePrinter(printer, text)
win32print.EndPagePrinter(printer)
win32print.EndDocPrinter(printer)
win32print.ClosePrinter(printer)
def main():
printer_name = "Canon Inkjet iP1800 series" # or get_printer_names()[0]
prn = win32print.OpenPrinter(printer_name)
error = printer_errorneous_state(prn)
if error:
print("ERROR occurred: ", error)
else:
print("Printer OK...")
# Do the real work
win32print.ClosePrinter(prn)
def _printout(self, rawdata):
if self.printerParam['connectionMethod'] == 'network':
self.printer.sendall(rawdata)
self._closeNetworkPrinter()
if self.printerParam['connectionMethod'] == 'usb':
hJob = win32print.StartDocPrinter(self.printer, 1,
("Test print", None, "RAW"))
win32print.WritePrinter(self.printer, rawdata)
win32print.EndPagePrinter(self.printer)
win32print.ClosePrinter(self.printer)
def cancelPrint(printerName, docName):
phandle = win32print.OpenPrinter(printerName)
print_jobs = win32print.EnumJobs(phandle, 0, -1, 1)
for job in print_jobs:
if docName in job["pDocument"]:
document = job["pDocument"]
print("Canceling Print: " + document)
win32print.SetJob(phandle, job["JobId"], 0, None,
win32print.JOB_CONTROL_DELETE)
win32print.ClosePrinter(phandle)
time.sleep(1)
def sendjob(self, fp, title = "Raw Print Server Job"):
hprinter = win32print.OpenPrinter(self.printer_name)
hjob = win32print.StartDocPrinter(hprinter, 1, (title, None, "RAW"))
try:
blk = fp.read(8192)
while blk:
win32print.WritePrinter(hprinter, blk)
blk = fp.read(8192)
except:
import traceback
traceback.print_exc(file = sys.stdout)
win32print.EndDocPrinter(hprinter)
win32print.ClosePrinter(hprinter)
def printer_job(printer_name, printer_file):
hPrinter = win32print.OpenPrinter(printer_name)
try:
hJob = win32print.StartDocPrinter(hPrinter, 1, ("test of raw data", None, "RAW"))
try:
win32print.StartPagePrinter(hPrinter)
# win32print.WritePrinter (hPrinter, raw_data)
win32print.WritePrinter(hPrinter, printer_file)
win32print.EndPagePrinter(hPrinter)
finally:
win32print.EndDocPrinter(hPrinter)
finally:
win32print.ClosePrinter(hPrinter)
def printRaw(self, printer, data, title):
hPrinter = win32print.OpenPrinter(printer)
try:
win32print.StartDocPrinter(hPrinter, 1, (title, None, "RAW"))
try:
win32print.StartPagePrinter(hPrinter)
win32print.WritePrinter(hPrinter, base64.b64decode(data))
win32print.EndPagePrinter(hPrinter)
finally:
win32print.EndDocPrinter(hPrinter)
finally:
win32print.ClosePrinter(hPrinter)
return 0
def set_duplex(printer_no, duplex):
print_defaults = {"DesiredAccess": win32print.PRINTER_ALL_ACCESS}
handle = win32print.OpenPrinter(app_config.PRINTER_NAMES[printer_no],
print_defaults)
level = 2
attributes = win32print.GetPrinter(handle, level)
attributes['pDevMode'].Duplex = duplex
try:
win32print.SetPrinter(handle, level, attributes, 0)
except Exception as e:
print('Failed to set duplex')
print(e)
finally:
win32print.ClosePrinter(handle)
