def build_tabla_cabecera(canvas, datos_albaran, y1):
# Cabecera.
canvas.saveState()
x1 = 1.0 * cm + 1
limite = x1 + 0.9 * PAGE_WIDTH
incremento = (limite - x1) / 3
#y1 = 22.5 * cm
y2 = y1 - 18
for texto, clave in (("Código cliente", "codcliente"),
("Nº Albarán", "número"),
("Fecha", "fecha")):
x2 = x1 + incremento
canvas.setFont("Times-Roman", 12)
dato_albaran = escribe(datos_albaran[clave])
rectangulo(canvas,
(x1, y1),
(x2, y2),
texto = dato_albaran,
alinTxtX = "centro",
alinTxtY = "centro")
canvas.setFont("Times-Roman", 10)
canvas.drawString(x1+0.2*cm, y1 + 3, texto)
x1 += incremento
canvas.restoreState()
# Página x de y.
canvas.saveState()
canvas.setFont("Times-Italic", 9)
canvas.drawRightString(0.9 * PAGE_WIDTH - 0.5 * cm,
1.0 * cm,
escribe("Página %d de " % canvas.getPageNumber()))
canvas.doForm("lastPageNumber")
canvas.restoreState()
def print_tabla(c, medidas, medidas_tabla):
y0 = medidas["ldvs"][1]
y1 = y0 - medidas_tabla["hcab"]
# Cabecera
c.saveState()
c.setFillColorRGB(1, 1, 1)
geninformes.rectangulo(
c,
(medidas_tabla["xnumalb"], y0),
(medidas_tabla["xdesc"], y1),
geninformes.escribe("Nº Albarán"),
alinTxtX="centro",
alinTxtY="centro",
color_relleno=(0, 0.5, 0),
)
geninformes.rectangulo(
c,
(medidas_tabla["xdesc"], y0),
(medidas_tabla["xfecha"], y1),
geninformes.escribe("Descripción"),
alinTxtX="centro",
alinTxtY="centro",
color_relleno=(0, 0.5, 0),
)
geninformes.rectangulo(
c,
(medidas_tabla["xfecha"], y0),
(medidas_tabla["xkgs"], y1),
geninformes.escribe("Fecha"),
alinTxtX="centro",
alinTxtY="centro",
color_relleno=(0, 0.5, 0),
)
geninformes.rectangulo(
c,
(medidas_tabla["xkgs"], y0),
(medidas_tabla["ximporte"], y1),
geninformes.escribe("Kg y Precio"),
alinTxtX="centro",
alinTxtY="centro",
color_relleno=(0, 0.5, 0),
)
geninformes.rectangulo(
c,
(medidas_tabla["ximporte"], y0),
(medidas["ldvs"][2], y1),
geninformes.escribe("Importe"),
alinTxtX="centro",
alinTxtY="centro",
color_relleno=(0, 0.5, 0),
)
c.restoreState()
# Líneas verticales
c.line(medidas["ldvs"][0], medidas["ldvs"][1], medidas["ldvs"][0], medidas["ldvs"][3])
c.line(medidas["ldvs"][2], medidas["ldvs"][1], medidas["ldvs"][2], medidas["ldvs"][3])
# Líneas horizontales
c.line(medidas["ldvs"][0], medidas["ldvs"][3], medidas["ldvs"][2], medidas["ldvs"][3])
# Total
c.saveState()
c.setFont("Helvetica-Bold", 12)
c.restoreState()
def etiqueta_rollos_portrait(rollos, mostrar_marcado = True):
"""
Construye una etiqueta
"""
# Voy a tratar de reescribir esto regla en mano a ver si consigo
# cuadrarlo bien en la etiquetadora GEMINI.
height = 12.55 * cm
width = 8.4 * cm
# Escala
ancho = 7.2 # @UnusedVariable
alto = 11.3
scale = height / alto
# Medidas en papel.
brand = (0.4 * scale, (alto - 2.0) * scale)
logo = (3.8 * scale, (alto - 2.8) * scale)
marcado = ((7.2/2) * scale, (alto - 3.0) * scale)
column1 = .35 * scale
column2 = logo[0]
lineas = map(lambda x: (alto - x) * scale,
[3.4 + (i*.6) for i in range(13)])
# Datos
data = {'brand': "EkoTex",
"c100": "UK Distributor",
"c108": "Product Name",
"c109": "Roll Number",
"c110": "Product Dimensions",
"c111": "Polymer",
"c112": "Product Classification",
"c200": "Geosynthetics Limited",
"c201": "Fleming Road",
"c202": "Harrowbrook Ind Est",
"c203": "Hinckley",
"c204": "Leicestershire",
"c205": "LE10 3 DU",
"c206": "Tel 01455 617139",
"c207": "Fax 01455 617140",
"c211": "Polypropylene",
"c212": "GTX-N",
"marcado": "0799-CPD", # Hay que incluirle el logotipo CE delante.
}
data["logo"] = os.path.abspath(os.path.join(os.path.dirname(__file__),
"..", "imagenes", "logo_ekotex.png"))
# Ruta absoluta
# a la imagen del logotipo.
try:
logo_marcado = os.path.abspath(os.path.join(os.path.dirname(__file__),
"..", "imagenes", "CE.png"))
except IOError: # Reportlab o PIL sin soporte libzip
logo_marcado = os.path.abspath(os.path.join(os.path.dirname(__file__),
"..", "imagenes", "CE.gif"))
# Creo la hoja
nomarchivo = os.path.join(gettempdir(),
"etiqEkotex_%s.pdf" % give_me_the_name_baby())
c = canvas.Canvas(nomarchivo, pagesize = (width, height))
for rollo in rollos:
try:
data["c208"] = rollo['objeto'].productoVenta.nombre
data["c209"] = rollo['objeto'].numrollo
cer = rollo['objeto'].productoVenta.camposEspecificosRollo
except AttributeError: # No se ha creado el objeto todavía. Es None.
data["c208"] = rollo['productoVenta'].nombre
data["c209"] = rollo['nrollo']
cer = rollo['productoVenta'].camposEspecificosRollo
data["c210"] = "%sm x %dm" % (float2str(cer.ancho,
autodec = True,
separador_decimales = "."),
cer.metrosLineales)
rectangulo(c, (0.3 * cm, 0.3 * cm),
(width - 0.3 * cm, height - 0.3 * cm))
c.setFont("Helvetica-Bold", 16)
c.drawString(brand[0], brand[1], escribe(data['brand']))
c.setFont("Helvetica-Bold", 10)
c.drawString(column1, lineas[0], escribe(data['c100']))
c.drawString(column1, lineas[8], escribe(data['c108']))
c.drawString(column1, lineas[9], escribe(data['c109']))
c.drawString(column1, lineas[10], escribe(data['c110']))
c.drawString(column1, lineas[11], escribe(data['c111']))
c.drawString(column1, lineas[12], escribe(data['c112']))
c.drawString(column2, lineas[0], escribe(data['c200']))
c.drawString(column2, lineas[1], escribe(data['c201']))
c.drawString(column2, lineas[2], escribe(data['c202']))
c.drawString(column2, lineas[3], escribe(data['c203']))
c.drawString(column2, lineas[4], escribe(data['c204']))
c.drawString(column2, lineas[5], escribe(data['c205']))
c.drawString(column2, lineas[6], escribe(data['c206']))
c.drawString(column2, lineas[7], escribe(data['c207']))
c.drawString(column2, lineas[8], escribe(data['c208']))
c.drawString(column2, lineas[9], escribe(data['c209']))
c.drawString(column2, lineas[10], escribe(data['c210']))
c.drawString(column2, lineas[11], escribe(data['c211']))
c.drawString(column2, lineas[12], escribe(data['c212']))
c.drawImage(data['logo'], logo[0], logo[1],
2.5 * cm, 2.5 * cm)
if mostrar_marcado and not rollo['defectuoso']:
c.drawImage(logo_marcado,
marcado[0]
- ((0.30*cm
+ c.stringWidth(data['marcado']) ) / 2),
marcado[1],
width = 0.35 * cm,
height = 6)
c.setFont("Helvetica-Bold", 8)
c.drawCentredString(marcado[0] + ((0.35*cm) / 2),
marcado[1],
escribe(data["marcado"]))
#c.setPageRotation(-90)
#c.rotate(-90)
c.showPage()
c.save()
return nomarchivo
def crear_etiquetas_bigbags(bigbags, mostrar_marcado=True, lang="es"):
"""
Construye una etiqueta por cada objeto bigbag recibido y las devuelve
en un solo PDF.
Si lang = "en", etiqueta en inglés. Si "es", en castellano.
"""
# Voy a tratar de reescribir esto regla en mano a ver si consigo
# cuadrarlo bien en la etiquetadora GEMINI.
alto = 12.55 * cm
ancho = 8.4 * cm
# Creo la hoja
nomarchivo = os.path.join(
gettempdir(), "etiq_bigbag13_%s_%s.pdf" % (lang, give_me_the_name_baby()))
canvas = reportlabcanvas.Canvas(nomarchivo, pagesize=(ancho, alto))
# Medidas:
logo = (3.8 * cm * 0.75, 2.8 * cm * 0.75)
margen = 0.1 * cm
marcado = (((ancho - logo[0]) / 2) - margen, (alto - margen - logo[1] - 2))
# Imágenes:
logo_marcado = os.path.abspath(
os.path.join(os.path.dirname(__file__), "..", "imagenes", "CE.png"))
# Datos fijos:
# pylint: disable=bad-continuation
_data = {# "00 logo_marcado": None,
"01 texto_marcado": "1035", # Fijo
"02 fabricado_por": "Fabricado por: %s",
"03 direccion1": None,
"04 direccion2": None,
"05 telefono": "Tfno: %s, %s",
"06 año_certif": None,
"07 blanco1": "", # Separador
"08 dni": None,
"09 iso1": "EN 14889-2:2008", # Fijo
"11 blanco2": "", # Separador
"12 producto": None,
"13 descripcion": "",
"14 uso": None,
"15 blanco3": "", # Separador
# "16 1 separador": "", # Fijo
"16 codigo": "Lote {} · Bigbag {}", # Código bigbag y código lote.
"17 caracteristicas": "Corte: {} mm · Peso: {} kg/br" # Corte y peso.
}
if lang == "en":
for k in _data:
_data[k] = helene_laanest(_data[k])
estilos = defaultdict(lambda: ("Helvetica-Bold", 11)) # Helvética a 11 por defecto
estilos["01 texto_marcado"] = ("Times-Bold", 9)
estilos["02 fabricado_por"] = ("Helvetica-Bold", 13)
estilos["12 producto"] = ("Courier-Bold", 17)
estilos["14 uso"] = ("Helvetica-Bold", 10)
estilos["15 blanco3"] = ("Helvetica-Bold", 10)
estilos["16 codigo"] = ("Courier-Bold", 13)
estilos["17 caracteristicas"] = ("Helvetica-Bold", 14)
data = {}
# Datos de la BD dependientes del bigbag
for bigbag in bigbags:
# 0.- ¿En qué formato viene? Si es el antiguo (datos en diccionario)
# me quedo con el objeto de pclases en sí.
producto_venta = bigbag.articulo.productoVenta
numpartida = bigbag.articulo.loteCem.codigo
numbigbag = bigbag.codigo
# 1.- Empresa
try:
# Si hay distribuidor, este texto cambia.
distribuidor = bigbag.articulo.productoVenta.camposEspecificosBala.cliente
if distribuidor:
if lang == "en":
data["02 fabricado_por"] = helene_laanest(
"%s") % (distribuidor.nombre)
else:
data["02 fabricado_por"] = "%s" % (
distribuidor.nombre)
dird = distribuidor.get_direccion_completa()
dircompleta = textwrap.wrap(dird,
(len(dird) + max([len(w) for w in dird.split()])) / 2)
data["03 direccion1"] = dircompleta[0]
data["04 direccion2"] = dircompleta[1]
data["05 telefono"] = _data["05 telefono"] % (
distribuidor.telefono, distribuidor.email)
else: # Sigo con los datos de "propia empresa". Distribuyo yo.
empresa = pclases.DatosDeLaEmpresa.select()[0]
data["02 fabricado_por"] = _data["02 fabricado_por"] % (
empresa.nombre)
data["03 direccion1"] = empresa.direccion + ", " + empresa.cp
data["04 direccion2"] = ", ".join((empresa.ciudad,
empresa.provincia,
empresa.pais))
data["05 telefono"] = _data["05 telefono"] % (empresa.telefono,
empresa.email)
# Para los clientes sin teléfono o sin email:
data["05 telefono"] = data["05 telefono"].strip()
if data["05 telefono"].startswith(","):
data["05 telefono"] = data["05 telefono"][1:]
if data["05 telefono"].endswith(","):
data["05 telefono"] = data["05 telefono"][:-1]
if len(data["05 telefono"]) <= 7:
data["05 telefono"] = ""
except IndexError:
data["02 fabricado_por"] = ""
data["03 direccion1"] = ""
data["04 direccion2"] = ""
data["05 telefono"] = ""
# 2.- Producto
producto = producto_venta
if producto.annoCertificacion != None:
data["06 año_certif"] = "%02d" % producto.annoCertificacion
else:
data["06 año_certif"] = ""
data["08 dni"] = producto.dni
data["12 producto"] = producto.nombre
if producto.uso:
if lang == "en":
produso = helene_laanest(producto.uso)
else:
produso = producto.uso
if len(produso) > 30: # Wrap si el texto es largo.
produso = textwrap.wrap(produso,
(len(produso) + max([len(w) for w in produso.split()])) / 2)
data["14 uso"] = produso[0]
data["15 blanco3"] = produso[1] # Era un separador, pero
# necesito el espacio.
else:
data["14 uso"] = produso
else:
data["14 uso"] = ""
# 3.- Bigbag
data["16 codigo"] = _data["16 codigo"].format(numpartida,
numbigbag)
corte = producto.camposEspecificosBala.corte
peso = float2str(bigbag.articulo.peso_bruto)
corte_peso = _data["17 caracteristicas"].format(corte, peso)
data["17 caracteristicas"] = corte_peso
rectangulo(canvas, (margen, margen),
(ancho - margen, alto - margen))
if mostrar_marcado:
canvas.drawImage(logo_marcado,
marcado[0],
marcado[1],
width=logo[0], height=logo[1])
else:
data["01 texto_marcado"] = ""
lineas = _data.keys()
lineas.sort()
# Posición y estilo de la primera línea.
tamfuente = estilos[lineas[0]][1]
crd_y = alto - logo[1] - 0.1 * cm - tamfuente
# ¿Cuánto me desplazaré de línea a línea?
offset_y = (crd_y - margen) / len(lineas)
for linea in lineas:
try:
dato = data[linea]
except KeyError: # Si no está en los valores asignados, busco
# en los originales. Deben ser datos fijos.
dato = _data[linea]
if dato is None:
dato = ""
canvas.setFont(*estilos[linea])
#canvas.drawCentredString((ancho / 2),
# crd_y,
# escribe(dato))
el_encogedor_de_fuentes_de_doraemon(canvas,
fuente=estilos[linea][0],
tamannoini=estilos[linea][1],
xini=margen,
xfin=ancho - margen,
y=crd_y,
texto=dato,
alineacion=0)
crd_y -= offset_y
canvas.showPage()
canvas.save()
return nomarchivo
def etiqueta_rollos_norma13(rollos, mostrar_marcado=True, lang="es"):
"""
Construye una etiqueta por cada objeto rollo recibido y las devuelve
en un solo PDF.
Si lang = "en", etiqueta en inglés. Si "es", en castellano.
"""
# Voy a tratar de reescribir esto regla en mano a ver si consigo
# cuadrarlo bien en la etiquetadora GEMINI.
alto = 12.55 * cm
ancho = 8.4 * cm
# Creo la hoja
nomarchivo = os.path.join(gettempdir(),
"etiq_norma13_{}_{}.pdf".format(
lang, give_me_the_name_baby()))
canvas = reportlabcanvas.Canvas(nomarchivo, pagesize=(ancho, alto))
# Medidas:
logo = (3.8 * cm * 0.75, 2.8 * cm * 0.75)
margen = 0.1 * cm
marcado = (((ancho - logo[0]) / 2) - margen, (alto - margen - logo[1] - 2))
# Imágenes:
logo_marcado = os.path.abspath(
os.path.join(os.path.dirname(__file__), "..", "imagenes", "CE.png"))
# Datos fijos:
# pylint: disable=bad-continuation
_data = {# "00 logo_marcado": None,
"01 texto_marcado": "1035", # Fijo
"02 fabricado_por": "Fabricado por: %s",
"03 direccion1": None,
"04 direccion2": None,
"05 telefono": "Tfno: %s, %s",
"06 año_certif": None,
"07 blanco1": "", # Separador
"08 dni": None,
# "09 iso1": "De EN13249:2001 a EN13257:2001", # Fijo
# "10 iso2": "EN13265:2001", # Fijo
# La norma ha cambiado. Ahora nos regimos por la del 2014
"09 iso1": "De EN13249:2014 a EN13257:2014", # Fijo
"10 iso2": "EN13265:2014", # Fijo
"11 blanco2": "", # Separador
"12 producto": None,
"13 descripcion":
"Geotextil no tejido de polipropileno 100% virgen",
"14 uso": "Uso: %s",
"15 blanco3": "", # Separador
"16 codigo": "Partida: %d Rollo: %s",
"17 caracteristicas": "Gramaje: %d g/m² Ancho: %s m Largo: %d m"
}
if lang == "en":
for k in _data:
_data[k] = helene_laanest(_data[k])
estilos = defaultdict(lambda: ("Helvetica", 9)) # Helvética a 9 por defecto
estilos["02 fabricado_por"] = ("Helvetica-Bold", 11)
estilos["12 producto"] = ("Helvetica-Bold", 17)
estilos["16 codigo"] = ("Helvetica-Bold", 17)
estilos["17 caracteristicas"] = ("Helvetica-Bold", 13)
data = {}
# Datos de la BD dependientes del rollo
for rollo in rollos:
# 0.- ¿En qué formato viene? Si es el antiguo (datos en diccionario)
# me quedo con el objeto de pclases en sí.
if isinstance(rollo, dict):
try:
producto_venta = rollo['productoVenta']
except KeyError:
# Si no me lo mandan en el diccionario, tiene que traer
# el objeto rollo. Los partes mandan producto en dicccionario
# porque a veces se genera etiqueta antes de crear el objeto
# en la BD. Si viene de la consulta del listado de rollos,
# como el rollo ya existe, me viene en el objeto toda la info.
producto_venta = rollo['objeto'].productoVenta
numpartida = utils.parse_numero(rollo['partida'])
numrollo = rollo['nrollo']
barcode39 = rollo['codigo39']
else:
producto_venta = rollo.productoVenta
numpartida = rollo.partida.numpartida
numrollo = rollo.numrollo
barcode39 = rollo.codigo
# 1.- Empresa
try:
# Si hay distribuidor, este texto cambia.
distribuidor = producto_venta.camposEspecificosRollo.cliente
if distribuidor:
if lang == "en":
data["02 fabricado_por"] = helene_laanest(
"%s") % (distribuidor.nombre)
else:
data["02 fabricado_por"] = "%s" % (
distribuidor.nombre)
dird = distribuidor.get_direccion_completa()
dircompleta = textwrap.wrap(dird,
(len(dird) + max([len(w) for w in dird.split()])) / 2)
data["03 direccion1"] = dircompleta[0]
data["04 direccion2"] = dircompleta[1]
data["05 telefono"] = _data["05 telefono"] % (
distribuidor.telefono, distribuidor.email)
else: # Sigo con los datos de "propia empresa". Distribuyo yo.
empresa = pclases.DatosDeLaEmpresa.select()[0]
data["02 fabricado_por"] = _data["02 fabricado_por"] % (
empresa.nombre)
data["03 direccion1"] = empresa.direccion + ", " + empresa.cp
data["04 direccion2"] = ", ".join((empresa.ciudad,
empresa.provincia,
empresa.pais))
data["05 telefono"] = _data["05 telefono"] % (empresa.telefono,
empresa.email)
# Para los clientes sin teléfono o sin email:
data["05 telefono"] = data["05 telefono"].strip()
if data["05 telefono"].startswith(","):
data["05 telefono"] = data["05 telefono"][1:]
if data["05 telefono"].endswith(","):
data["05 telefono"] = data["05 telefono"][:-1]
if len(data["05 telefono"]) <= 7:
data["05 telefono"] = ""
except IndexError:
data["02 fabricado_por"] = ""
data["03 direccion1"] = ""
data["04 direccion2"] = ""
data["05 telefono"] = ""
# 2.- Producto
producto = producto_venta
if producto.annoCertificacion != None:
data["06 año_certif"] = "%02d" % producto.annoCertificacion
else:
data["06 año_certif"] = ""
data["08 dni"] = producto.dni
if len(producto.nombre) <= 50:
data["12 producto"] = producto.nombre
else:
#if "//" in producto.nombre: # Productos Intermas
# data["11 blanco2"], data["12 producto"] = producto.nombre.split("//")
#else:
data["11 blanco2"], data["12 producto"] = utils.dividir_cadena(
producto.nombre)
data["11 blanco2"] = data["11 blanco2"].strip()
data["12 producto"] = data["12 producto"].strip()
estilos["11 blanco2"] = estilos["12 producto"]
if producto.uso:
if lang == "en":
data["14 uso"] = _data["14 uso"] % helene_laanest(producto.uso)
else:
data["14 uso"] = _data["14 uso"] % producto.uso
else:
data["14 uso"] = ""
# 3.- Rollo
data["16 codigo"] = _data["16 codigo"] % (numpartida,
numrollo)
data["17 caracteristicas"] = _data["17 caracteristicas"] % (
producto.camposEspecificosRollo.gramos,
float2str(producto.camposEspecificosRollo.ancho,
autodec=True, separador_decimales="."),
producto.camposEspecificosRollo.metrosLineales)
rectangulo(canvas, (margen, margen),
(ancho - margen, alto - margen))
if mostrar_marcado:
canvas.drawImage(logo_marcado,
marcado[0],
marcado[1],
width=logo[0], height=logo[1])
else:
data["01 texto_marcado"] = ""
lineas = _data.keys()
lineas.sort()
# Posición y estilo de la primera línea.
tamfuente = estilos[lineas[0]][1]
crd_y = alto - logo[1] - 0.1 * cm - tamfuente
# ¿Cuánto me desplazaré de línea a línea?
offset_y = (crd_y - margen) / (len(lineas) + 3) # 3 líneas para barcode
for linea in lineas:
try:
dato = data[linea]
except KeyError: # Si no está en los valores asignados, busco
# en los originales. Deben ser datos fijos.
dato = _data[linea]
if dato is None:
dato = ""
canvas.setFont(*estilos[linea])
#canvas.drawCentredString((ancho / 2),
# crd_y,
# escribe(dato))
el_encogedor_de_fuentes_de_doraemon(canvas,
fuente=estilos[linea][0],
tamannoini=estilos[linea][1],
xini=margen,
xfin=ancho - margen,
y=crd_y,
texto=dato,
alineacion=0)
crd_y -= offset_y
# Lo último: el código de barras:
#######################################################################
canvas.saveState()
crd_y -= 2*offset_y
crd_y -= 0.2*cm
codigo_rollo = barcode39
codigobarras = Extended39(codigo_rollo, xdim=.065*cm)
codigobarras.drawOn(canvas, margen-0.5*cm, crd_y)
xcode = ancho / 2.0
ycode = 0.15*cm
canvas.setFont("Courier-Bold", 9)
try:
canvas.drawCentredString(xcode, ycode, codigo_rollo, charSpace=0.25*cm)
except TypeError: # Versión antigua de ReportLab.
canvas.drawCentredString(xcode, ycode, codigo_rollo)
canvas.restoreState()
# Y el QR de regalo
# # De momento lo desactivo porque nuestras pistolas no lo reconocen.
#try:
# from lib.pyqrcode import pyqrcode
# bidicode = pyqrcode.create(codigo_rollo)
# nomfichbidi = os.path.join(gettempdir(),
# "bidi_%s.svg" % give_me_the_name_baby())
# bidicode.svg(nomfichbidi, scale=3)
# from lib.svglib.svglib import svglib
# drawing = svglib.svg2rlg(nomfichbidi)
# drawing.drawOn(canvas, margen - 0.25*cm, alto - margen - 3.0*cm + 0.25*cm)
#except ImportError:
# pass # No hay bidi porque no hay lxml instalado. Probablemente.
# print("No se generará código QR. Puede intentar lo siguiente:")
# print("C:\Python27\Scripts\easy_install.exe pip")
# print('pip install "D:\Informatica\Software\softwin python 2.7'
# '\lxml-3.7.2-cp27-cp27m-win32.whl"')
#######################################################################
canvas.showPage()
# Y ahora la etiqueta adicional por si se pierde la otra y para cargar.
create_etiqueta_backup(canvas, rollo)
canvas.showPage()
canvas.save()
return nomarchivo
def crear_etiquetas_balas(balas, mostrar_marcado=True, lang="es"):
"""
Construye una etiqueta por cada objeto bala recibido y las devuelve
en un solo PDF.
Si lang = "en", etiqueta en inglés. Si "es", en castellano.
Crea etiquetas para las balas de
un parte de la línea de fibra.
Una por etiqueta del tamaño estándar de la impresora CAB: 12.55 x 8.4.
Lleva el código especial para Domenech en horizontal.
«seriep» es la serie del pedido y si no es None, se muestra en los
3 primeros dígitos.
«numped» es el número de pedido procedente de Domenech y si no es None se
muestra en 6 dígitos tras la serie (si la hubiera).
Estos dos grupos de dígitos opcionales («seriep» y «numped») son comunes
a toda la serie de balas de las que se generarán las etiquetas.
El formato completo es:
* 3 dígitos: serie del pedido, completado con ceros por la izquierda.
* 6 dígitos: número de pedido, completado con ceros por la izquierda.
*-7-dígitos:-código-de-producto:--- YA NO (tercera vez que vuelven a ser 6)
* 6 dígitos: código de producto:
- 007336 FIBRA PP 6.7 Dtx NATURAL.
- 007337 FIBRA PP 6.7 Dtx NEGRO.
- 007674 FIBRA PP 4.5 Dtx NEGRO.
- 007852 FIBRA PP 4.5 Dtx NATURAL.
* 10 dígitos: número de lote, completado con ceros por la izquierda.
* 15 dígitos: número de bala, completado con ceros por la izquierda.
* 3 dígitos: parte entera del peso de la bala en kilogramos,
completado con ceros por la izquierda.
* 2 dígitos: parte decimal del peso de la bala en kilogramos,
completado con ceros por la derecha.
Por ejemplo, el código correspondiente a una bala de fibra negra de
polipropileno de 6.7 dtex, correspondiente al lote 660, de número
57394, con 286.50 kg de peso y solicitada en el pedido 4/2158; sería:
004002158007337000000066000000000005739428650
007337000000066000000000005739428650 Si no lleva serie ni pedido.
"""
# TODO: De momento solo español. No hay inglés. Se ignora el parámetro.
from reportlab.pdfgen import canvas
from informes.geninformes import escribe, _build_codigo_domenech
try:
import Image
except ImportError:
from PIL import Image
width = 12.55 * cm
height = 8.4 * cm
# Creo la hoja
nomarchivo = os.path.join(gettempdir(),
"dh_etiqbala_%s.pdf"%give_me_the_name_baby())
c = canvas.Canvas(nomarchivo, pagesize = (width, height))
ancho, alto = width, height
# arribaArriba significa linea de "arriba" de los cuadros de "Arriba"
# El 0 vertical es el borde de abajo
# El 0 horizontal es el margen derecho
arriba = alto - 1.45*cm
#arriba = alto - 5
abajo = 5
#abajo = 1.45*cm
izq = width - 5
der = 5 # ¿Va a resultar al final que también soy disléxico?
xLogo = der + 0.5 * cm
yLogo = arriba - 1.3 * cm
xIzquierda = 20
xDerecha = ancho/2 + 0.25*inch
yPrimeraLinea = yLogo - 0.8*inch
ySegundaLinea = yPrimeraLinea - 0.31*inch
yTerceraLinea = ySegundaLinea - 0.31*inch
yCuartaLinea = yTerceraLinea - 0.31*inch
yQuintaLinea = yCuartaLinea - 0.31*inch
xCodigo = xDerecha + 3.50 * cm
yCodigo = arriba - 3.75 * cm
for bala in balas: # @UnusedVariable
if not bala: # Es None. Por lo que sea :o
continue
if isinstance(bala, pclases.Articulo):
bala = _build_dict_etiqueta_articulo_bala(bala)
rectangulo(c, (izq, arriba), (der, abajo))
c.setFont("Helvetica-Bold", 28)
c.drawString(xLogo, yLogo, "GEOTEXAN S.A.")
c.setFont("Helvetica", 14)
c.drawString(xIzquierda,
yPrimeraLinea,
escribe("CÓDIGO: " + bala['codigo']))
from barcode import code39
codigobarras = code39.Extended39(bala['codigo'], xdim = .020*inch)
codigobarras.drawOn(c, xIzquierda - 0.5 * cm, yPrimeraLinea + 15)
c.drawString(xIzquierda,
yQuintaLinea,
escribe("COLOR: %s" % (bala['color'])))
c.drawString(xIzquierda,
ySegundaLinea,
escribe("LOTE: %s" % (bala['lote'])))
c.drawString(xDerecha,
ySegundaLinea,
escribe("PESO KG: %s" % (bala['peso'])))
c.drawString(xIzquierda,
yTerceraLinea,
escribe("TIPO: %s" % (bala['tipo'])))
c.drawString(xDerecha,
yTerceraLinea,
escribe("LONGITUD: %s" % (bala['longitud'])))
c.drawString(xIzquierda,
yCuartaLinea,
escribe("BALA Nº: %s" % (bala['nbala'])))
c.drawString(xDerecha,
yCuartaLinea,
escribe("DTEX: %s" % (bala['dtex'])))
c.drawString(xDerecha,
yQuintaLinea,
escribe("ACABADO: %s" % (bala['acabado'])))
from barcode.EANBarCode import EanBarCode
bar = EanBarCode()
nombreficheroean13 = bar.getImage(bala['codigoBarra'])
ean13rotado = Image.open(nombreficheroean13)
ean13rotado = ean13rotado.rotate(90)
ean13rotado.save(nombreficheroean13)
c.drawImage(nombreficheroean13, xCodigo, yCodigo)
# XXX: DOMENECH:
from barcode import code128
seriep = None # Esto ya no se usa. Es la serie del pedido para el cliente
numped = None # Esto ya no se usa. Es el núm. del pedido para el cliente
codigodomenech = _build_codigo_domenech(bala, seriep, numped)
if codigodomenech:
barcodedomenech = code128.Code128(codigodomenech,
#xdim = 0.015 * inch,
#height = 0.5 * cm)
xdim = 0.0205 * inch,
height = 0.95 * cm)
#barcodedomenech = code39.Extended39(codigodomenech,
# #xdim = 0.015 * inch,
# #height = 0.5 * cm)
# xdim = 0.0094 * inch,
# height = 0.95 * cm)
ydom = alto - 1.2 * cm
#ydom = 0.4 * cm
xdom = (width - barcodedomenech.width) / 2.0
barcodedomenech.drawOn(c, xdom, ydom)
c.saveState()
c.setFont("Courier-Bold", 8)
c.drawCentredString(xdom + (barcodedomenech.width / 2.0),
ydom - 0.20 * cm,
codigodomenech)
c.restoreState()
# XXX: EODOMENECH
# XXX: Marca para identificar las nuevas.
c.saveState()
c.setFillColorRGB(0, 0, 0)
c.circle(izq - 0.3*cm, yQuintaLinea, 0.1*cm, fill=1)
c.restoreState()
# XXX: EOMarca
c.showPage()
c.save()
return nomarchivo
def print_tabla(c, hlin, tampag,rm, maxlineas, medidas_tabla):
xcantidad = medidas_tabla["xcantidad"]
xconcepto = medidas_tabla["xconcepto"]
xcateg = medidas_tabla["xcateg"]
xkgs = medidas_tabla["xkgs"]
xprecio = medidas_tabla["xprecio"]
ximporte = medidas_tabla["ximporte"]
y0 = medidas_tabla["y0"]
yfinal = medidas_tabla["yfinal"]
y1 = medidas_tabla["y1"]
# Cabecera
c.saveState()
c.setFillColorRGB(1, 1, 1)
geninformes.rectangulo(c,
(xcantidad, y0),
(xconcepto, y1),
geninformes.escribe("Cantidad"),
alinTxtX = "centro",
alinTxtY = "centro",
color_relleno = (0, 0.5, 0))
geninformes.rectangulo(c,
(xconcepto, y0),
(xcateg, y1),
geninformes.escribe("Concepto"),
alinTxtX = "centro",
alinTxtY = "centro",
color_relleno = (0, 0.5, 0))
geninformes.rectangulo(c,
(xcateg, y0),
(xkgs, y1),
geninformes.escribe("Categ."),
alinTxtX = "centro",
alinTxtY = "centro",
color_relleno = (0, 0.5, 0))
geninformes.rectangulo(c,
(xkgs, y0),
(xprecio, y1),
geninformes.escribe("Kgs"),
alinTxtX = "centro",
alinTxtY = "centro",
color_relleno = (0, 0.5, 0))
geninformes.rectangulo(c,
(xprecio, y0),
(ximporte, y1),
geninformes.escribe("Precio"),
alinTxtX = "centro",
alinTxtY = "centro",
color_relleno = (0, 0.5, 0))
geninformes.rectangulo(c,
(ximporte, y0),
(tampag[0] - rm, y1),
geninformes.escribe("Importe"),
alinTxtX = "centro",
alinTxtY = "centro",
color_relleno = (0, 0.5, 0))
c.restoreState()
# Relleno
c.saveState()
c.setFillColorRGB(0.9, 1, 0.9)
c.rect(xcantidad, 1.75*cm, tampag[0] - rm - xcantidad, y1 - 1.75*cm,
stroke = 0, fill=1)
c.restoreState()
# Líneas verticales
c.line(xcantidad, y1, xcantidad, yfinal)
c.line(xconcepto, y1, xconcepto, yfinal)
c.line(xcateg, y1, xcateg, yfinal)
c.line(xkgs, y1, xkgs, yfinal)
c.line(xprecio, y1, xprecio, yfinal)
c.line(ximporte, y1, ximporte, yfinal)
c.line(tampag[0] - rm, y1, tampag[0] - rm, yfinal)
c.saveState()
c.setStrokeColorRGB(1, 1, 1)
c.line(xconcepto, y0, xconcepto, y1)
c.line(xcateg, y0, xcateg, y1)
c.line(xkgs, y0, xkgs, y1)
c.line(xprecio, y0, xprecio, y1)
c.line(ximporte, y0, ximporte, y1)
c.restoreState()
# Líneas horizontales
for i in range(maxlineas):
y1 -= hlin
c.line(xcantidad, y1, tampag[0] - rm, y1)
# Total
c.saveState()
c.setFont("Helvetica-Bold", 12)
c.drawRightString(ximporte - 0.15*cm, medidas_tabla["ytotal"] + 0.2*cm,
geninformes.escribe("Total"))
c.restoreState()
geninformes.rectangulo(c,
(ximporte, y1),
(tampag[0] - rm, medidas_tabla["ytotal"]),
color_relleno = (0.9, 1, 0.9))
def cabecera_y_cliente(canvas,
doc,
datos_cliente,
datos_de_la_empresa,
datos_albaran):
"""
Escribe el texto "ALBARÁN" y los datos del cliente.
Los datos del cliente vienen en un diccionario con:
código (de cliente), cif, razón social, dirección, población, provincia.
"""
fuente = "Helvetica"
tamanno = 24
canvas.saveState()
canvas.setFont(fuente, tamanno)
canvas.drawString(PAGE_WIDTH
- canvas.stringWidth(escribe("ALBARÁN"),fuente,tamanno)
- 1.0*cm,
PAGE_HEIGHT - 1.5*cm,
escribe("ALBARÁN"))
canvas.restoreState()
tamanno = 12
altura_linea = 16
xCliente = (PAGE_WIDTH - 1*cm) / 2.5
linea = (PAGE_HEIGHT-1.5*cm) - 0.10*cm - 2*cm
rectangulo(canvas,
(xCliente - 0.2*cm, PAGE_HEIGHT - 1.5*cm + altura_linea - 2*cm),
(PAGE_WIDTH - 1*cm,
(PAGE_HEIGHT- 1.5*cm + altura_linea)
-(altura_linea*5 + 0.5*cm) - 2*cm)
)
canvas.drawString(xCliente,
linea,
escribe(
"Cód. cliente: %s C.I.F.: %s" % (
datos_cliente['código'],
datos_cliente['cif'])))
linea -= altura_linea
el_encogedor_de_fuentes_de_doraemon(canvas,
fuente,
tamanno,
xCliente,
PAGE_WIDTH - 1*cm,
linea,
escribe(datos_cliente['razón social']))
linea -= altura_linea
el_encogedor_de_fuentes_de_doraemon(canvas,
fuente,
tamanno,
xCliente,
PAGE_WIDTH - 1*cm,
linea,
escribe(datos_cliente['dirección']))
linea -= altura_linea
canvas.drawString(xCliente,
linea,
escribe(datos_cliente['población']))
linea -= altura_linea
canvas.drawString(xCliente,
linea,
escribe(datos_cliente['provincia']))
# Datos de la empresa
dibujar_datos_empresa(canvas, datos_de_la_empresa)
# Cabecera de factura
build_tabla_cabecera(canvas, datos_albaran, 22.5*cm)
def etiqueta_rollos_polaco(rollos, mostrar_marcado = True):
"""
Construye una etiqueta en polaco para Alians Trade.
"""
# Dimensiones de la etiqueta en impresora térmica GEMINI.
height = h = 12.55 * cm
width = w = 8.4 * cm
MARGEN = 0.05 * cm
if DEBUG:
print_debug(height = height, width = width)
try:
logo_marcado = os.path.abspath(os.path.join(os.path.dirname(__file__),
"..", "imagenes", "CE.png"))
except IOError: # Reportlab o PIL sin soporte libzip
logo_marcado = os.path.abspath(os.path.join(os.path.dirname(__file__),
"..", "imagenes", "CE.gif"))
logo_alians = os.path.abspath(os.path.join(os.path.dirname(__file__),
"..", "imagenes", "alians_trade.png"))
WM = 1.0 * cm
WA = 1.5 * cm
im_width, im_height = Image.open(logo_marcado).size
WH_MARCADO = (WM, im_height * (WM / im_width))
im_width, im_height = Image.open(logo_alians).size
WH_ALIANS = (WA, im_height * (WA / im_width))
if DEBUG:
print_debug(WH_MARCADO = WH_MARCADO, WH_ALIANS = WH_ALIANS)
# Medidas relativas sobre papel.
H_TEXTMARCADO = 0.2 * cm
xy_logo = (1.5*mm, h - (WH_MARCADO[1] + H_TEXTMARCADO + WH_ALIANS[1]))
xy_ce = ((w - WH_MARCADO[0]) / 2, h - WH_MARCADO[1] - 1.5*mm)
xy_textmarcado = (w/2, xy_logo[1] + WH_ALIANS[1] - H_TEXTMARCADO)
if DEBUG:
print_debug(xy_ce = xy_ce, xy_textmarcado = xy_textmarcado,
xy_logo = xy_logo)
# Datos
texto_marcado1 = "1488-CPD-0275/Z"
texto_marcado2 = "12"
X_HEADER = WH_ALIANS[0] + 0.2*cm
data = [("PRODUCENT/PRODUCER:", {'x': X_HEADER,
'format': CENTER}),
("ALIANS TRADE SP. Z O.O.", {'x': X_HEADER,
'format': BOLD + CENTER}),
("ul. Wyzwolenia 367a, 43-300 Bielsko-Biała",
{'x': X_HEADER, 'format': CENTER}),
("www.alians-trade.eu", {'x': X_HEADER, 'format': CENTER}),
("ZAKŁAD PRODUKCYJNY/FACTORY CODE: 34-133",
{'x': X_HEADER, 'format': CENTER}),
("NAZWA PRODUKTU/ PRODUCT NAME:", {'format': CENTER}),
#("Geowłóknina PINEMA® ST ", {'format': CENTER}),
("$PRODUCTO", {'format': CENTER}),
# Geowłóknina PINEMA® ST + Texto variable {80, 100, 180, 250}
("geowłóknina wyprodukowana ze 100% polipropylenu/",
{'format': CENTER}),
("nonwoven geotextile composed of 100% polypropilene",
{'format': CENTER}),
"NORMY/ APPLICATION STANDARDS:",
("EN 13249:2000, EN 13250:2000, EN 13251:2000, EN 13252:2000,",
{'format': BOLD}),
("EN 13253:2000, EN 13254:2000, EN 13255:2000, EN 13256:2000,",
{'format': BOLD}),
("EN 13257:2000, EN 13265:2000,", # Negrita
{'format': BOLD}),
# Las siguientes 5 líneas en fuente más pequeña.
("EN 13249:2000/A1:2005, EN 13250:2000/A1:2005, EN 13251:2000/A1:2005,",
{'size': SIZE-1}),
("EN 13252:2000/A1:2005, EN 13253:2000/A1:2005, EN 13254:2000/AC:2003,",
{'size': SIZE-1}),
("EN 13254:2000/A1:2005, EN 13255:2000/AC:2003, EN 13255:2000/A1:2005,",
{'size': SIZE-1}),
("EN 13256:2000/AC:2003,EN 13256:2000/A1:2005, EN 13257:2000/AC:2003,",
{'size': SIZE-1}),
# Esta última, además de pequeña, en negrita.
("EN 13257:2000/A1:2005, EN 13265:2000/AC:2003, EN 13265:2000/A1:2005",
{'format': BOLD, 'size': SIZE-1}),
"ZASTOSOWANIE/ APPLICATION: w drogownictwie, kolejnictwie, w robotach ",
"ziemnych i konstrukcjach oporowych, w systemach drenażowych, w ",
"zabezpieczeniach antyerozyjnych, w budowie zbiorników wodnych i zapór, ",
"w budowie kanałów, tuneli i konstrukcji podziemnych, w budowie ",
"składowisk odpadów stałych i zbiorników odpadów ciekłych.",
"PRZEZNACZENIE/ INTENDED FUNCTIONS: rozdzielenie, filtracja, ",
"drenaż, wzmocnienie.",
# De aquí para abajo, en dos columnas
(("NR ROLKI/ ", "GRAMATURA/"),
{'size': SIZE - 2}),
(("ROLL NO.:", "$NUMROLLO", "NOMINAL MASS (g/m2):", "$GRAMAJE"),
{'format': ITALIC, 'size': SIZE - 2}),
(("DŁUGOŚĆ/", "SZEROKOŚĆ/"),
{'size': SIZE - 2}),
(("LENGHT (m):", "$LARGO", "WIDTH (m):", "$ANCHO"),
{'format': ITALIC, 'size': SIZE - 2}),
(("WAGA BRUTTO/", "DATA PRODUKCJI/"),
{'size': SIZE - 2}),
(("GROSS WEIGHT (kg):", "$PESO", "DATE OF PRODUCTION:", "$FECHA"),
{'format': ITALIC, 'size': SIZE - 2})
]
# 31 líneas. En principio distribuyo uniformemente:
alto_linea = (xy_textmarcado[1] - 2*H_TEXTMARCADO) / (len(data) + 1)
# (0,0) está abajo. Yo relleno la etiqueta de arriba a abajo.
y_lines = [(xy_textmarcado[1] - 2*H_TEXTMARCADO) - (y * alto_linea)
for y in range(len(data) +1)[1:]]
if DEBUG:
print_debug(y_lines = y_lines)
print_debug(alto_linea = alto_linea)
# Creo la hoja
nomarchivo = os.path.join(gettempdir(),
"etiqAliansT_%s.pdf" % give_me_the_name_baby())
c = canvas.Canvas(nomarchivo, pagesize = (width, height))
# import code; code.interact(local = locals())
for rollo in rollos:
# Elementos gráficos: borde etiqueta y logos.
rectangulo(c, (MARGEN, MARGEN),
(width - MARGEN, height - MARGEN))
c.drawImage(logo_alians, xy_logo[0], xy_logo[1],
WH_ALIANS[0], WH_ALIANS[1])
if mostrar_marcado and not rollo['defectuoso']:
c.drawImage(logo_marcado,
xy_ce[0], xy_ce[1],
width = WH_MARCADO[0],
height = WH_MARCADO[1])
c.setFont("Helvetica-Bold", SIZE)
c.drawCentredString(xy_textmarcado[0],
xy_textmarcado[1],
escribe(texto_marcado1))
c.drawCentredString(xy_textmarcado[0],
xy_textmarcado[1] - H_TEXTMARCADO,
escribe(texto_marcado2))
c.setFont(FONT, SIZE)
# Texto de la etiqueta
c.setFont(FONT, SIZE)
for i in range(len(data)):
#c.drawString(0, y_lines[i], escribe(data[i]))
#c.drawString(2*mm, y_lines[i], data[i])
if isinstance(data[i], (list, tuple)):
texto = data[i][0]
opciones = data[i][1]
if not isinstance(opciones, dict):
texto = (texto, opciones)
else:
texto = data[i]
opciones = {}
render(c, 2*mm, y_lines[i], texto, opciones = opciones,
fuente = FONT, tamanno = SIZE, w = w, h = h,
margen = MARGEN, rollo = rollo)
c.showPage()
c.save()
return nomarchivo
def etiqueta_rollos_norma13(rollos, mostrar_marcado = True, lang = "es"):
"""
Construye una etiqueta por cada objeto rollo recibido y las devuelve
en un solo PDF.
Si lang = "en", etiqueta en inglés. Si "es", en castellano.
"""
# Voy a tratar de reescribir esto regla en mano a ver si consigo
# cuadrarlo bien en la etiquetadora GEMINI.
alto = 12.55 * cm
ancho = 8.4 * cm
# Creo la hoja
nomarchivo = os.path.join(gettempdir(),
"etiq_norma13_%s_%s.pdf" % (lang, give_me_the_name_baby()))
c = canvas.Canvas(nomarchivo, pagesize = (ancho, alto))
# Medidas:
logo = (3.8 * cm * 0.75, 2.8 * cm * 0.75)
margen = 0.1 * cm
marcado = (((ancho - logo[0]) / 2) - margen, (alto - margen - logo[1] - 2))
# Imágenes:
logo_marcado = os.path.abspath(os.path.join(os.path.dirname(__file__),
"..", "imagenes", "CE.png"))
# Datos fijos:
_data = {# "00 logo_marcado": None,
"01 texto_marcado": "1035", # Fijo
"02 fabricado_por": "Fabricado por: %s",
"03 direccion1": None,
"04 direccion2": None,
"05 telefono": "Tfno: %s, %s",
"06 año_certif": None,
"07 blanco1": "", # Separador
"08 dni": None,
#"09 iso1": "De EN13249:2001 a EN13257:2001", # Fijo
#"10 iso2": "EN13265:2001", # Fijo
# La norma ha cambiado. Ahora nos regimos por la del 2014
"09 iso1": "De EN13249:2014 a EN13257:2014", # Fijo
"10 iso2": "EN13265:2014", # Fijo
"11 blanco2": "", # Separador
"12 producto": None,
"13 descripcion":
"Geotextil no tejido de polipropileno 100% virgen",
"14 uso": "Uso: %s",
"15 blanco3": "", # Separador
"16 codigo": "Partida: %d Rollo: %s",
"17 caracteristicas": "Gramaje: %d g/m² Ancho: %s m Largo: %d m"
}
if lang == "en":
for k in _data:
_data[k] = helene_laanest(_data[k])
estilos = defaultdict(lambda: ("Helvetica", 9)) # Helvética a 9 por defecto
estilos["02 fabricado_por"] = ("Helvetica-Bold", 11)
estilos["12 producto"] = ("Helvetica-Bold", 17)
estilos["16 codigo"] = ("Helvetica-Bold", 17)
estilos["17 caracteristicas"] = ("Helvetica-Bold", 13)
data = {}
# Datos de la BD dependientes del rollo
for rollo in rollos:
# 0.- ¿En qué formato viene? Si es el antiguo (datos en diccionario)
# me quedo con el objeto de pclases en sí.
if isinstance(rollo, dict):
try:
productoVenta = rollo['productoVenta']
except KeyError:
# Si no me lo mandan en el diccionario, tiene que traer
# el objeto rollo. Los partes mandan producto en dicccionario
# porque a veces se genera etiqueta antes de crear el objeto
# en la BD. Si viene de la consulta del listado de rollos,
# como el rollo ya existe, me viene en el objeto toda la info.
productoVenta = rollo['objeto'].productoVenta
numpartida = utils.parse_numero(rollo['partida'])
numrollo = rollo['nrollo']
else:
productoVenta = rollo.productoVenta
numpartida = rollo.partida.numpartida
numrollo = rollo.numrollo
# 1.- Empresa
try:
# Si hay distribuidor, este texto cambia.
distribuidor = productoVenta.camposEspecificosRollo.cliente
if distribuidor:
if lang == "en":
data["02 fabricado_por"] = helene_laanest(
"Distribuido por: %s") % (distribuidor.nombre)
else:
data["02 fabricado_por"] = "Distribuido por: %s" % (
distribuidor.nombre)
d = distribuidor.get_direccion_completa()
dircompleta = textwrap.wrap(d,
(len(d) + max([len(w) for w in d.split()])) / 2)
data["03 direccion1"] = dircompleta[0]
data["04 direccion2"] = dircompleta[1]
data["05 telefono"] = _data["05 telefono"] % (
distribuidor.telefono, distribuidor.email)
else: # Sigo con los datos de "propia empresa". Distribuyo yo.
empresa = pclases.DatosDeLaEmpresa.select()[0]
data["02 fabricado_por"] = _data["02 fabricado_por"] % (
empresa.nombre)
data["03 direccion1"] = empresa.direccion + ", " + empresa.cp
data["04 direccion2"] = ", ".join((empresa.ciudad,
empresa.provincia,
empresa.pais))
data["05 telefono"] = _data["05 telefono"] % (empresa.telefono,
empresa.email)
# Para los clientes sin teléfono o sin email:
data["05 telefono"] = data["05 telefono"].strip()
if data["05 telefono"].startswith(","):
data["05 telefono"] = data["05 telefono"][1:]
if data["05 telefono"].endswith(","):
data["05 telefono"] = data["05 telefono"][:-1]
if len(data["05 telefono"]) <= 7:
data["05 telefono"] = ""
except IndexError:
data["02 fabricado_por"] = ""
data["03 direccion1"] = ""
data["04 direccion2"] = ""
data["05 telefono"] = ""
# 2.- Producto
producto = productoVenta
if producto.annoCertificacion != None:
data["06 año_certif"] = "%02d" % producto.annoCertificacion
else:
data["06 año_certif"] = ""
data["08 dni"] = producto.dni
if len(producto.nombre) <= 50:
data["12 producto"] = producto.nombre
else:
#if "//" in producto.nombre: # Productos Intermas
# data["11 blanco2"], data["12 producto"] = producto.nombre.split("//")
#else:
data["11 blanco2"], data["12 producto"] = utils.dividir_cadena(
producto.nombre)
data["11 blanco2"] = data["11 blanco2"].strip()
data["12 producto"] =data["12 producto"].strip()
estilos["11 blanco2"] = estilos["12 producto"]
if producto.uso:
if lang == "en":
data["14 uso"] = _data["14 uso"] % helene_laanest(producto.uso)
else:
data["14 uso"] = _data["14 uso"] % producto.uso
else:
data["14 uso"] = ""
# 3.- Rollo
data["16 codigo"] = _data["16 codigo"] % (numpartida,
numrollo)
data["17 caracteristicas"] = _data["17 caracteristicas"] % (
producto.camposEspecificosRollo.gramos,
float2str(producto.camposEspecificosRollo.ancho,
autodec = True, separador_decimales = "."),
producto.camposEspecificosRollo.metrosLineales)
rectangulo(c, (margen, margen),
(ancho - margen, alto - margen))
if mostrar_marcado:
c.drawImage(logo_marcado,
marcado[0],
marcado[1],
width = logo[0], height = logo[1])
else:
data["01 texto_marcado"] = ""
lineas = _data.keys()
lineas.sort()
# Posición y estilo de la primera línea.
tamfuente = estilos[lineas[0]][1]
y = alto - logo[1] - 0.1 * cm - tamfuente
# ¿Cuánto me desplazaré de línea a línea?
offset_y = (y - margen) / len(lineas)
for linea in lineas:
try:
dato = data[linea]
except KeyError: # Si no está en los valores asignados, busco
# en los originales. Deben ser datos fijos.
dato = _data[linea]
if dato is None:
dato = ""
c.setFont(*estilos[linea])
#c.drawCentredString((ancho / 2),
# y,
# escribe(dato))
el_encogedor_de_fuentes_de_doraemon(c,
fuente = estilos[linea][0],
tamannoini = estilos[linea][1],
xini = margen,
xfin = ancho - margen,
y = y,
texto = dato,
alineacion = 0)
y -= offset_y
c.showPage()
c.save()
return nomarchivo
def cabecera_y_cliente(canvas,
doc,
datos_cliente,
datos_de_la_empresa,
titular,
datos_albaran):
"""
Escribe el texto "ALBARÁN/CARTA DE PORTE" y los datos del cliente.
Los datos del cliente vienen en un diccionario con:
código (de cliente), cif, razón social, dirección, población, provincia.
"""
fuente = "Helvetica"
tamanno = 12
canvas.drawString(1.0*cm,
PAGE_HEIGHT - 1.5*cm,
escribe("ALBARÁN/CARTA DE PORTE"))
altura_linea = 16
xCliente = (PAGE_WIDTH - 1*cm) / 2.5
linea = (PAGE_HEIGHT-1.5*cm) - 0.10*cm
rectangulo(canvas,
(xCliente - 0.2*cm, PAGE_HEIGHT - 1.5*cm + altura_linea),
(PAGE_WIDTH - 1*cm,
(PAGE_HEIGHT- 1.5*cm + altura_linea)-(altura_linea*5 + 0.5*cm))
)
canvas.drawString(xCliente,
linea,
escribe(
"Cód. cliente: %s C.I.F.: %s" % (
datos_cliente['código'],
datos_cliente['cif'])))
linea -= altura_linea
el_encogedor_de_fuentes_de_doraemon(canvas,
fuente,
tamanno,
xCliente,
PAGE_WIDTH - 1*cm,
linea,
escribe("Razón social: %s"
% datos_cliente['razón social']))
#canvas.drawString(xCliente,
# linea,
# escribe("Razón social: %s"%datos_cliente['razón social']))
linea -= altura_linea
el_encogedor_de_fuentes_de_doraemon(canvas,
fuente,
tamanno,
xCliente,
PAGE_WIDTH - 1*cm,
linea,
escribe("Dirección: %s"
% datos_cliente['dirección']))
#canvas.drawString(xCliente,
# linea,
# escribe("Dirección: %s" % datos_cliente['dirección']))
linea -= altura_linea
canvas.drawString(xCliente,
linea,
escribe("Población: %s" % datos_cliente['población']))
linea -= altura_linea
canvas.drawString(xCliente,
linea,
escribe("Provincia: %s" % datos_cliente['provincia']))
# Y el pie de página:
logo, empresa = build_logo_y_empresa_por_separado(datos_de_la_empresa)
LineaHorizontal(0.9 * PAGE_WIDTH).drawOn(canvas, 78.0, 12.5*cm)
LineaHorizontal(0.9 * PAGE_WIDTH).drawOn(canvas, 78.0, 12.4 *cm)
logo.drawOn(canvas, 3*cm, 10 * cm)
fuente = "Helvetica"
tamanno = 10
for i in range(len(empresa)):
linea = 11.5 * cm
el_encogedor_de_fuentes_de_doraemon(canvas,
fuente,
tamanno,
5.25*cm,
PAGE_WIDTH - 1*cm,
linea - (i*0.5*cm),
escribe(empresa[i]))
#logo_y_empresa.drawOn(canvas, 10.5*cm, 78.0)
texto = build_texto(titular)
lineas = []
for l in [p.text for p in texto._content]:
lineas.extend(l.split("\n"))
y = 9.5*cm
tamanno = 8
centrado = False
for linea in lineas:
linea = linea.replace(" ", "")
if "<b>" in linea:
fuente = "Times-Bold"
linea = linea.replace("<b>", "").replace("</b>", "")
# Aprovechando que el Pisuerga...
centrado = True
else:
fuente = "Times-Roman"
if "<font size=12>" in linea:
tamanno = 12
linea = linea.replace("<font size=12>", "").replace("</font>", "")
else:
tamanno = 10
lineas_agregadas = agregarFila(1*cm,
y,
PAGE_WIDTH - 1*cm,
escribe(linea),
canvas,
fuente,
tamanno,
centrado = centrado)
y -= lineas_agregadas * 10
#canvas.drawString(PAGE_WIDTH - 2*cm, 2*cm, str(canvas.getPageNumber()))
#texto.drawOn(canvas, 9*cm, 72.0)
# Página x de y.
canvas.saveState()
canvas.setFont("Times-Italic", 9)
canvas.drawRightString(PAGE_WIDTH - 1.5*cm,
12.7*cm,
escribe("Página %d de " % canvas.getPageNumber()))
canvas.doForm("lastPageNumber")
canvas.restoreState()
# Cabecera.
# Sí, ahora va aquí. No hace falta que ponga el CWT, ¿o sí?
canvas.saveState()
x1 = 1.0 * cm + 1
limite = x1 + 0.9 * PAGE_WIDTH
incremento = (limite - x1) / 4
y1 = 24.5 * cm
y2 = y1 - 18
for texto, clave in (("Fecha", "fecha"),
("Nº Albarán", "número"),
("Kilos", "kilos"),
("Bultos", "bultos")):
x2 = x1 + incremento
canvas.setFont("Times-Roman", 12)
rectangulo(canvas,
(x1, y1),
(x2, y2),
texto = escribe(datos_albaran[clave]),
alinTxtX = "centro",
alinTxtY = "centro")
canvas.setFont("Times-Roman", 10)
canvas.drawString(x1+0.2*cm, y1 + 3, texto)
x1 += incremento
canvas.restoreState()
