295 lines
12 KiB
Python
Executable file
295 lines
12 KiB
Python
Executable file
#!/usr/bin/env python
|
|
# -*- coding: iso-8859-15 -*-
|
|
|
|
# Utilisé par /var/www/impression/analyse.py
|
|
# /usr/lib/cups/backend/devis et /usr/lib/cups/backend/laserjet
|
|
# Écrit initial par Benoit
|
|
# modifié par Brice DUBOST et Benoit
|
|
|
|
import locale
|
|
locale.setlocale(locale.LC_ALL, 'fr_FR')
|
|
|
|
import commands, os, string, sys
|
|
import tempfile # non utilisé en ce moment
|
|
|
|
sys.path.append('/usr/scripts/gestion')
|
|
from config import impression
|
|
|
|
|
|
class cout:
|
|
"""Classe pour le calcul du cout d'une impression et de sa mise en page"""
|
|
#en centimes
|
|
c_total=0
|
|
#en euros
|
|
c_total_euros=0
|
|
total_noir=0
|
|
total_couleur=0
|
|
faces=1
|
|
pages=1
|
|
nb_copie=1
|
|
taille=""
|
|
erreur=""
|
|
recto_v="None"
|
|
media=""
|
|
|
|
def __init__(self, fichierps, media="", mode_couleur="Couleur", recto_v="None", taille="A4", nb_copie=1):
|
|
""" * fichierps est le fichier PostScript (ou pdf) à analyser
|
|
* media vaut transparent le cas écheant (dans ce cas taille=A4)
|
|
* mode_couleur = Couleur pour traiter en couleur
|
|
* recto_v = Recto si l'on ne desire pas un recto-verso
|
|
* taille vaut A3 ou A4 selon le bac choisi
|
|
* nb_copie est le nombre de copies désirées
|
|
Le PostScript a toujours priorité sur ces parametres
|
|
"""
|
|
|
|
# Pour la couleur, je n'ai pas trouve de methode valables tout le temps
|
|
# Le plus simple reste donc de voir s'il y a 0% de couleur dans le ps.
|
|
|
|
self.nb_copie=nb_copie
|
|
# on compte le nb de copies et on enlève les balises pour ne pas recalculer
|
|
nb_copie_ps=0
|
|
original=open(fichierps)
|
|
fichier='/tmp/couts_temp'
|
|
try:
|
|
fic = open(fichier,'w')
|
|
except:
|
|
os.remove(fichier)
|
|
fic = open(fichier,'w')
|
|
# fic = tempfile.NamedTemporaryFile()
|
|
ligne = original.readline()
|
|
while ligne:
|
|
if ligne.startswith('%%BeginFeature: *PageSize'):
|
|
taille=ligne.split(' ')[-1].strip()
|
|
if ligne.startswith('%%BeginFeature: *Duplex'):
|
|
recto_v=ligne.split(' ')[-1].strip()
|
|
if ligne.find('%RBIBeginNonPPDFeature: *NumCopies') != -1:
|
|
nb_copie_ps=int(ligne.split(' ')[-1])
|
|
while ligne.find('%RBIEndNonPPDFeature') == -1:
|
|
ligne = original.readline()
|
|
ligne = original.readline()
|
|
fic.write(ligne)
|
|
ligne = original.readline()
|
|
fic.close()
|
|
original.close()
|
|
|
|
# Le PS a priorité
|
|
if nb_copie_ps:
|
|
self.nb_copie=nb_copie_ps
|
|
|
|
self.taille=taille
|
|
if not (taille=="A4" or taille=="A3"):
|
|
self.erreur="Taille invalide"
|
|
return
|
|
|
|
if recto_v == "None" or recto_v == "Recto":
|
|
recto_v="Recto"
|
|
else:
|
|
recto_v="Recto-verso"
|
|
|
|
self.recto_v=recto_v
|
|
|
|
if (mode_couleur == "Couleur"):
|
|
device = "png16m"
|
|
else:
|
|
device = "pnggray"
|
|
|
|
if (self.taille == "A3"):
|
|
# Une feuille A3 couvre 2 fois plus de surface que A4
|
|
c_taille = impression.c_a3
|
|
cout_coul = 2*impression.c_coul
|
|
cout_noir = 2*impression.c_noir
|
|
else:
|
|
cout_coul = impression.c_coul
|
|
cout_noir = impression.c_noir
|
|
if (media == "transparent"):
|
|
c_taille = impression.c_trans
|
|
self.media="transparent"
|
|
else:
|
|
c_taille = impression.c_a4
|
|
|
|
# Vérification du format de fichier.
|
|
try:
|
|
en_tete=open(fichier).read(4)
|
|
except:
|
|
self.erreur="Le fichier ne peut etre ouvert"
|
|
return
|
|
# On vérifie que ce que l'on nous a envoyé est bien un PS ou un PDF
|
|
if en_tete!='%!PS' and en_tete!='%PDF':
|
|
self.erreur="Format de fichier non supporte"
|
|
return
|
|
|
|
(status,rep) = commands.getstatusoutput("nice -n 10 gs -sDEVICE=%s -r100 -dBATCH -dNOPAUSE -dSAFER -dPARANOIDSAFER -dGraphicsAlphaBits=4 -dTextAlphaBits=4 -dMaxBitmap=50000000 -sOutputFile='%s' -q '%s'" % (device, fichier+"%d.png", fichier) )
|
|
if (status != 0):
|
|
self.erreur="ERREUR : Ghostscript : Fichier Postscript invalide.\n"
|
|
self.erreur="Le message d'erreur est le suivant :\n"
|
|
self.erreur+= rep
|
|
# On détaille l'erreur dans le mail et
|
|
# il faut stopper l'impression.
|
|
return
|
|
|
|
# On a plus besoin du fichier temp, donc on le supprime.
|
|
os.remove(fichier)
|
|
|
|
if not os.system("ls '%s'*.png > /dev/null" % (fichier)):
|
|
if (mode_couleur == "Couleur"):
|
|
remplissage = [0, 0, 0, 0, 0] # C, M, J, N, nombre de pages
|
|
for file in string.split(commands.getoutput("ls '%s'*.png" % (fichier)),"\n"):
|
|
resultats = commands.getoutput("/usr/scripts/impression/percentcolour '%s'" % (file) )
|
|
l_resultats = string.split(resultats,":")
|
|
for i in [0, 1, 2, 3]:
|
|
remplissage[i] += float(l_resultats[i])*float(l_resultats[4])
|
|
remplissage[4] += float(l_resultats[4])
|
|
os.system("rm -f '%s'" % (file))
|
|
self.total_noir = remplissage[3]
|
|
self.total_couleur = sum(remplissage[0:3])
|
|
self.faces = int(remplissage[4])
|
|
if (recto_v == "Recto"):
|
|
self.pages = self.faces # nb de pages par copies
|
|
else:
|
|
self.pages = int(self.faces/2.+0.5)
|
|
if self.total_couleur > 0:
|
|
self.c_total = c_taille*self.pages+(impression.c_tambour_coul+impression.c_tambour_noir)*self.faces+cout_noir*self.total_noir+cout_coul*self.total_couleur
|
|
else: # Pas de couleur
|
|
self.c_total = c_taille*self.pages+impression.c_tambour_noir*self.faces+cout_noir*self.total_noir
|
|
else: # Utile pour la page web
|
|
remplissage = [0, 0] # Noir, nombre de pages
|
|
for file in string.split(commands.getoutput("ls '%s'*.png" % (fichier)),"\n"):
|
|
resultats = commands.getoutput("/usr/scripts/impression/percentblack '%s'" % (file))
|
|
l_resultats = string.split(resultats,":")
|
|
remplissage[0] += float(l_resultats[0])*float(l_resultats[1])
|
|
remplissage[1] += float(l_resultats[1])
|
|
os.system("rm -f '%s'" % (file))
|
|
self.total_noir = remplissage[0]
|
|
self.faces = int(remplissage[1])
|
|
if (recto_v == "Recto"):
|
|
self.pages = self.faces # nb de pages par copies
|
|
else:
|
|
self.pages = int(self.faces/2.+0.5)
|
|
self.c_total = c_taille*self.pages+impression.c_tambour_noir*self.faces+cout_noir*self.total_noir
|
|
self.c_total = int(self.nb_copie*self.c_total+impression.fact+0.5) # arrondi et facture
|
|
self.c_total_euros=float(self.c_total)/100
|
|
os.system("rm -f '%s'*.png" %(fichier))
|
|
else:
|
|
self.erreur=u"ERREUR : Fichier Postscript invalide. Aucun png n'a été créé\n"
|
|
|
|
|
|
|
|
def remplis_template(self,template):
|
|
"""Cette fonction rempli le template avec les bonnes valeurs"""
|
|
if (self.c_total < 100):
|
|
str_cout = "%s centimes d'euros" % (self.c_total)
|
|
else :
|
|
str_cout = "%s euros" % (self.c_total/100.)
|
|
|
|
if self.taille=="NON_VALIDE":
|
|
taille=u"Le format de papier que vous avez demandé n'est pas valide"
|
|
else:
|
|
if self.media=="transparent":
|
|
taille="transparent A4"
|
|
else:
|
|
taille=self.taille
|
|
try:
|
|
return template % { 'prix' : str_cout }
|
|
except:
|
|
return template % { 'noir' : self.total_noir, 'couleur' : self.total_couleur, 'faces' : self.faces, 'pages' : self.pages, 'copies' : self.nb_copie, 'taille' : taille, 'prix' : str_cout}
|
|
|
|
|
|
def html_cout(self):
|
|
"""Renvoie le cout formaté en html"""
|
|
# Format du PS (parfois different de celui choisi)
|
|
# Utile pour deboguage, sera supprime apres
|
|
template = """<b>Résultats : </b>
|
|
<ul><li><b>Taille de l'impression</b> : %(taille)s </li>
|
|
<li><b>Pour une copie :</b>
|
|
<ul><li>Noir : %(noir)s unités </li>
|
|
<li>Couleur : %(couleur)s unités </li>
|
|
<li>Nombre de faces : %(faces)s </li>
|
|
<li>Nombre de pages : %(pages)s </li></ul></li>
|
|
<li><b>Nombre de copies</b> : %(copies)s </li></ul>
|
|
<br>
|
|
<font size="3"><b>Prix total : %(prix)s </b></font>
|
|
</p>\n"""
|
|
|
|
if not self.erreur:
|
|
return self.remplis_template(template)
|
|
else:
|
|
return self.erreur
|
|
|
|
|
|
def send_mail(self, Dest , sujet, template):
|
|
"""Cette fonction envoie le mail template correctement rempli
|
|
provenant de l'imprimante avec comme serveur
|
|
SMTP localhost
|
|
Arguments :
|
|
Dest : destinataire
|
|
sujet : sujet du mail
|
|
template : le corps du mail
|
|
Pour le remplissage du template voir source pour le moment"""
|
|
|
|
if not self.erreur:
|
|
mail=self.remplis_template(template)
|
|
else:
|
|
sujet="Erreur " + sujet
|
|
# Provisoire, il faudra ameliore cela..
|
|
mail=self.erreur + template #"\n\n-- \nL'imprimante\n"
|
|
|
|
#l'envoi
|
|
self.send_email("Imprimante <%(From)s>" % { 'From' : impression.From_imprimante}, Dest , sujet, mail)
|
|
|
|
|
|
def send_email(self, sender, recipient, subject, body):
|
|
"""Send an email.
|
|
|
|
All arguments should be Unicode strings (plain ASCII works as well).
|
|
|
|
Only the real name part of sender and recipient addresses may contain
|
|
non-ASCII characters.
|
|
|
|
The email will be properly MIME encoded and delivered though SMTP to
|
|
localhost port 25. This is easy to change if you want something different.
|
|
|
|
The charset of the email will be the first one out of US-ASCII, ISO-8859-1
|
|
and UTF-8 that can represent all the characters occurring in the email.
|
|
"""
|
|
from smtplib import SMTP
|
|
from email.MIMEText import MIMEText
|
|
from email.Header import Header
|
|
from email.Utils import parseaddr, formataddr
|
|
|
|
# Header class is smart enough to try US-ASCII, then the charset we
|
|
# provide, then fall back to UTF-8.
|
|
header_charset = 'ISO-8859-1'
|
|
|
|
# We must choose the body charset manually
|
|
for body_charset in 'US-ASCII', 'ISO-8859-1', 'UTF-8':
|
|
try:
|
|
body.encode(body_charset)
|
|
except UnicodeError:
|
|
pass
|
|
else:
|
|
break
|
|
|
|
# Split real name (which is optional) and email address parts
|
|
sender_name, sender_addr = parseaddr(sender)
|
|
recipient_name, recipient_addr = parseaddr(recipient)
|
|
|
|
# We must always pass Unicode strings to Header, otherwise it will
|
|
# use RFC 2047 encoding even on plain ASCII strings.
|
|
sender_name = str(Header(unicode(sender_name), header_charset))
|
|
recipient_name = str(Header(unicode(recipient_name), header_charset))
|
|
|
|
# Make sure email addresses do not contain non-ASCII characters
|
|
sender_addr = sender_addr.encode('ascii')
|
|
recipient_addr = recipient_addr.encode('ascii')
|
|
|
|
# Create the message ('plain' stands for Content-Type: text/plain)
|
|
msg = MIMEText(body.encode(body_charset), 'plain', body_charset)
|
|
msg['From'] = formataddr((sender_name, sender_addr))
|
|
msg['To'] = formataddr((recipient_name, recipient_addr))
|
|
msg['Subject'] = Header(unicode(subject), header_charset)
|
|
|
|
# Send the message via SMTP to localhost:25
|
|
smtp = SMTP("localhost")
|
|
smtp.sendmail(sender, recipient, msg.as_string())
|
|
smtp.quit()
|
|
|