def build_news_frame(self):
pageData = {
"file": "home_pg.html",
"tipopg" :Environment.modulesList
}
self.html_news = renderTemplate(pageData)
renderHTML(self.htmlnewswidget, self.html_news)
def renderHTML(self, pageData=None, forprint=False):
pageData["forprint"] = forprint
self.pageData = pageData
self.html = renderTemplate(self.pageData)
if forprint:
return self.html
else:
renderHTML(self.detail, self.html)
def _refresh(self):
""" show the html page in the custom widget"""
pageData = {}
eventipreves = []
eventiprevesAT = []
calendarioDatetime = []
html = "<html><body></body></html>"
if not self._gtkHtml:
self._gtkHtml = self._anagrafica.getHtmlWidget()
if self.dao and self.dao.__class__.__name__ == "Articolo":
if posso("GN"):
from promogest.dao.TestataDocumento import TestataDocumento
from promogest.modules.GestioneNoleggio.dao.\
TestataGestioneNoleggio import TestataGestioneNoleggio
preves = TestataDocumento().select(daData=stringToDate("1/1/"
+ Environment.workingYear),
aData=stringToDate("31/12/"
+ Environment.workingYear),
batchSize=None,
idArticolo=self.dao.id)
for p in preves:
eventipreves.append((p.data_documento.toordinal(),
{"id": p.id,
"operazione": p.operazione,
"short": p.ragione_sociale_cliente,
"tipo": "data_documento",
"colore": "#6495ED"},
p.data_documento.day))
arcTemp = TestataGestioneNoleggio().select(
idTestataDocumento=p.id,
batchSize=None)
for a in arcTemp:
startDate = a.data_inizio_noleggio
stopDate = a.data_fine_noleggio
dateList = date_range(startDate, stopDate)
for d in dateList:
eventiprevesAT.append((d.toordinal(), {
"id": p.id,
"operazione": p.operazione,
"short": p.ragione_sociale_cliente,
"tipo": "data_documento",
"colore": "#AFEEEE"},
d.day))
calendarioDatetime = Calendar().yeardatescalendar(
int(Environment.workingYear))
self.dao = self.variations()
pageData = {
"file": self.defaultFileName + ".html",
"dao": self.dao,
"tipopg": Environment.modulesList,
"objects": self.dao,
"eventipreves": eventipreves,
"eventiprevesAT": eventiprevesAT,
"calendarioDatetime": calendarioDatetime,
}
html = renderTemplate(pageData)
self.hh = html
renderHTML(self._gtkHtml, html)
def refresh(self):
""" show the html page in the custom widget"""
self.bodyWidget.orderBy = self.orderBy
self.bodyWidget.veter = self._veter
#self.pbar_dialog.run()
#self.pbar_dialog.destroy()
daos = self.bodyWidget.runFilter(offset=None,
batchSize=None,
filterClosure=self._filterClosure,
)
#pbar(self.pbar_report,parziale=daos.index(ragsoc), totale=len(nomi), text=ragsoc, noeta=False)
#pbar(self.pbar_report,parziale=1, totale=4)
if hasattr(self._anagrafica,"funzione_ordinamento") and self._anagrafica.funzione_ordinamento == "cliforn":
if self._anagrafica.aa < 0:
daos.sort(key=lambda x: x.intestatario.strip().upper())
else:
daos.sort(key=lambda x: x.intestatario.strip().upper(),reverse=True)
elif hasattr(self._anagrafica,"funzione_ordinamento") and self._anagrafica.funzione_ordinamento == "impo":
for t in daos:
try:
t._totaleImponibileScontato
except:
t.totali
if self._anagrafica.aa < 0:
daos.sort(key=lambda x: x._totaleImponibileScontato)
else:
daos.sort(key=lambda x: x._totaleImponibileScontato,reverse=True)
self.numRecords = self.bodyWidget.countFilterResults(
self._filterCountClosure,
)
# self._refreshPageCount()
#pbar(self.pbar_report,parziale=2, totale=4)
pageData = {}
self.html_code = "<html><body></body></html>"
if self._veter:
daos = daos[:]
da = []
for d in daos:
c = []
for a in d.righe:
if "TRIPLICE" in a.rig.arti.denominazione_famiglia:
c.append(a)
if len(c)>0:
da.append(d)
daos = da
#pbar(self.pbar_report,parziale=2.5, totale=4)
if daos:
pageData = {
"file": self._previewTemplate[1],
#"dao":daos,
"objects": daos
}
self.html_code = renderTemplate(pageData)
#pbar(self.pbar_report,parziale=3.75, totale=4)
#pbar(self.pbar_report,stop=True)
#self.pbar_dialog.hide()
renderHTML(self.print_on_screen_html, self.html_code)
def _refreshHtml(self, data= None):
""" show the html page in the custom widget"""
html = '<html></html>'
if data:
pageData= {
"file":"creazione_taglie_colori.html",
"datas": data
}
html = renderTemplate(pageData)
renderHTML(self.html, html)
def refreshHtml(self, dao=None):
pageData = {}
self.html = '<html></html>'
if self.dao:
pageData = {
"file": "scontrino.html",
"dao" :self.dao,
"tutto":True,
}
self.html = renderTemplate(pageData)
renderHTML(self.detail,self.html)
def __init__(self, articolo):
GladeWidget.__init__(self, root='creazione_taglie_colore',
path='PromoWear/gui/creazione_varianti_taglia_colore.glade',
isModule=True)
self._loading = False
self.placeWindow(self.getTopLevel())
self._treeViewModel = None
self._articoloBase = articolo
self._articoloPadre = articolo.articoloTagliaColore
self.idGruppoTaglia = self._articoloBase.id_gruppo_taglia
if self._articoloPadre is None:
self._articoloPadre = ArticoloTagliaColore()
self._articoliTagliaColore = self._articoloBase.articoliTagliaColore
self._noValue = 'n/a'
self._varianti = {}
self._gruppoTaglia = None
#self._gtkHtml = None
self.order="color"
self.filtered = True
# Taglie attualmente presenti nella treeview
self._taglie = [] # Verra` aggiornato al refresh della combobox gruppi taglia
# Colori attualmente presenti nella treeview
self.refreshColori()
self.sizesAvailable()
self.selected = False
## Dizionario che associa alla chiave (taglia,colore) l'id della variante
self.group_size_label.set_markup('<span weight="bold">%s</span>'
% (self._articoloBase.denominazione_gruppo_taglia,))
self.father_label.set_markup('Articolo: ' + '<span weight="bold">%s %s</span>'
% (self._articoloBase.codice,self._articoloBase.denominazione))
# self._refreshHtml()
self.html = createHtmlObj(self)
self.anteprima_scrolled.add(self.html)
html = ""
renderHTML(self.html, html)
self.rowBackGround = '#E6E6FF'
self.rowBoldFont = 'arial bold 12'
self.draw()
self.__refresh()
def on_genera_report_button_clicked(self, button):
self.generatore = PGRiBa(self, self.__creditore)
self.generatore.bind(self.progressbar1)
data_inizio = stringToDate(self.data_inizio_entry.get_text())
data_fine = stringToDate(self.data_fine_entry.get_text())
pageData = {
'file': 'riba_export.html',
'creditore': self.__creditore,
'data_inizio': data_inizio,
'data_fine': data_fine,
}
res = 0
try:
res = self.generatore.analizza(data_inizio, data_fine, pageData=pageData)
except RuntimeError as e:
messageError(msg=str(e))
if res != 0:
self.salva_file_button.set_sensitive(True)
renderHTML(self.view, renderTemplate(pageData))
def refreshHtml(self, dao=None):
pageData = {}
#totali = self.calcolaTotale(self._scontrini)
self.html = '<html></html>'
dataeora = datetime.datetime.now()
dizio = {}
for s in self._scontrini:
tsc = TestataScontrinoCliente().select(id_testata_scontrino = s.id, batchSize=None)
if tsc:
cli_id = tsc[0].id_cliente
cli = Cliente().getRecord(id=cli_id)
if cli in dizio:
trini = dizio[cli]
trini.append(s)
dizio[cli] = trini
else:
dizio[cli] = [s]
pageData = {
"file": "acquisto_medio_cliente.html",
"dizio":dizio
}
self.html = renderTemplate(pageData)
renderHTML(self.detail,self.html)
def getHtmlFilterResultsWidget(self):
""" Return a treeview widget for filter results """
self.html = createHtmlObj(self)
html = """<html><body></body></html>"""
renderHTML(self.html, html)
return self.html
def create_planning_frame(self,d=1,m=1,y=0, currentData=None,view=None):
promeDict= {}
prevesDict = {}
prevesDictAT = {}
ordesDict = {}
ordesDictAT = {}
if d==1 and m==1 and y ==0 and not currentData:
currentData = datetime.date.today()
m = currentData.month
y = currentData.year
d = currentData.day
if currentData:
m = currentData.month
y = currentData.year
d = currentData.day
Environment.currentData = currentData
if view:
Environment.view = view
else:
try:
view = Environment.view
except:
view = "month"
weekDay = currentData.weekday()
workinMonth = Environment.workinMonth= m
workinYearc = Environment.workinYearc= y
self.anno_calendar_spinbutton.set_value(int(workinYearc))
workinDay = Environment.workinDay = d
if os.name=="nt":
dayName2 = calendar.day_name
dayName = [x.decode("iso8859-1") for x in dayName2]
else:
dayName2 = calendar.day_name
dayName = [x.decode("iso8859-1") for x in dayName2]
monthName = calendar.month_name
cale = calendar.Calendar().monthdatescalendar(workinYearc,workinMonth)
first_day = relativedelta(days=-(workinDay-1))
last_day = relativedelta(days=(last_day_of_month(workinYearc, workinMonth)-workinDay))
currentLastDay = currentData+last_day
currentFirstDay = currentData+first_day
eventipromes_ins = []
eventipromes_scad = []
if self.promemoria_ins_check.get_active():
promes = Promemoria().select(da_data_inserimento= currentFirstDay,
a_data_scadenza=currentLastDay, batchSize=None)
for p in promes:
eventipromes_ins.append((p.data_inserimento.toordinal(),{"id":p.id,
"short":p.oggetto,
"tipo":"data_inserimento",
"colore":"#F2859A"},p.data_inserimento.day))
if self.promemoria_scad_check.get_active():
promes = Promemoria().select(da_data_inserimento= currentFirstDay,
a_data_scadenza=currentLastDay, batchSize=None)
for p in promes:
eventipromes_scad.append((p.data_scadenza.toordinal(),{"id":p.id,
"short":p.oggetto,
"tipo":"data_scadenza",
"colore":"#148F14"},p.data_scadenza.day))
eventipreves = []
eventiprevesAT = []
if self.preventivi_check.get_active():
preves = TestataDocumento().select(daData= currentFirstDay,
aData=currentLastDay, batchSize=None,
idOperazione="Preventivo")
for p in preves:
eventipreves.append((p.data_documento.toordinal(),{"id":p.id,
"short":p.ragione_sociale_cliente,
"tipo":"data_documento",
"colore":"#6495ED"},p.data_documento.day))
if posso("GN"):
arcTemp = TestataGestioneNoleggio().select(idTestataDocumento=p.id, batchSize=None)
for a in arcTemp:
startDate =a.data_inizio_noleggio
stopDate =a.data_fine_noleggio
dateList= date_range(startDate,stopDate)
for d in dateList:
eventiprevesAT.append((d.toordinal(),{"id":p.id,
"short":p.ragione_sociale_cliente,
"tipo":"data_documento",
"colore":"#AFEEEE"},d.day))
eventiordes = []
eventiordesAT = []
if self.ordini_check.get_active():
ordes = TestataDocumento().select(daData= currentFirstDay,
aData=currentLastDay, batchSize=None,
idOperazione="Ordine da cliente")
for p in ordes:
eventiordes.append((p.data_documento.toordinal(),{
"id":p.id,
"short":p.ragione_sociale_cliente,
"tipo":"data_documento",
"colore":"#FFA500"},p.data_documento.day))
if posso("GN"):
arcTemp = TestataGestioneNoleggio().select(idTestataDocumento=p.id, batchSize=None)
for a in arcTemp:
startDate =a.data_inizio_noleggio
stopDate =a.data_fine_noleggio
dateList= date_range(startDate,stopDate)
for d in dateList:
eventiordesAT.append((d.toordinal(),{"id":p.id,
"short":p.ragione_sociale_cliente,
"tipo":"data_documento",
"colore":"red"},d.day))
onlyWeek = self.onlyWeek(cale, workinDay, workinMonth, workinYearc,dayName)
pageData = {"file": "planning.html",
"cale":cale,
"onlyWeek":onlyWeek,
"eventipromes_ins": eventipromes_ins,
"eventipromes_scad": eventipromes_scad,
"eventipreves":eventipreves,
"eventiprevesAT": eventiprevesAT,
"eventiordes":eventiordes,
"eventiordesAT": eventiordesAT,
"dayName" :dayName,
"monthName": monthName,
"workinDay":workinDay,
"weekDay":weekDay,
"workinMonth":workinMonth,
"workinYearc":workinYearc,
"view":view}
self.hhttmmll = renderTemplate(pageData)
renderHTML(self.htmlPlanningWidget,self.hhttmmll)
def renderHTML(self, pageData=None):
self.pageData = pageData
self.html = renderTemplate(self.pageData)
renderHTML(self.detail, self.html)
def refreshHtml(self, dao=None):
pageData = {}
parziali = []
totali = self.calcolaTotale(self._scontrini)
catelist =[]
self.html = '<html></html>'
dataeora = datetime.datetime.now()
ragione_sociale = Environment.azienda
chiusure = ChiusuraFiscale().select( dataChiusura = dataeora,
offset = None,
batchSize = None)
if chiusure:
aperto = "NO"
else:
aperto ="SI"
if self._scontrini:
cateDict = {}
for s in self._scontrini:
for una in s.righe:
articolo = Articolo().getRecord(id=una.id_articolo)
if articolo.id_categoria_articolo in cateDict:
righe = cateDict[articolo.id_categoria_articolo]
righe.append(una)
cateDict[articolo.id_categoria_articolo] = righe
else:
righe = []
righe.append(una)
cateDict[articolo.id_categoria_articolo] = righe
partz = self.aggiungiTotaliXRiga(cateDict)
if hasattr(Environment.conf, "VenditaDettaglio"):
magazzino = Environment.conf.VenditaDettaglio.magazzino
else:
magdao = setconf("VenditaDettaglio", "magazzino_vendita")
if magdao:
magazzino = Magazzino().getRecord(id=magdao).denominazione
castellettoIva = {}
for s in self._scontrini:
for r in s.righe:
a = leggiArticolo(r.id_articolo)
ali = a["percentualeAliquotaIva"]
prezzo_scontato = r.prezzo_scontato * r.quantita
imponibile = float(prezzo_scontato)/(1+float(ali)/100)
iva = float(prezzo_scontato) - imponibile
if ali not in castellettoIva.keys():
castellettoIva[ali] = {'percentuale': ali,
'imponibile': imponibile,
'imposta': iva,
'totale': prezzo_scontato
}
else:
castellettoIva[ali]['percentuale'] = ali
castellettoIva[ali]['imponibile'] += imponibile
castellettoIva[ali]['imposta'] += iva
castellettoIva[ali]['totale'] += prezzo_scontato
pageData = {
"file": "distinta_giornaliera.html",
"parziali": partz,
"totali": totali,
"dataeora": dataeora,
"ragione_sociale": ragione_sociale,
"aperto": aperto,
"magazzino":magazzino,
"castellettoIva": castellettoIva
}
self.html = renderTemplate(pageData)
renderHTML(self.detail,self.html)
def refresh(self):
""" show the html page in the custom widget"""
self.bodyWidget.orderBy = self.orderBy
self.bodyWidget.tipo = self._tipo
# self.pbar_dialog.run()
# self.pbar_dialog.destroy()
daos = self.bodyWidget.runFilter(offset=None,
batchSize=None,
filterClosure=self._filterClosure,
)
azienda = Azienda().getRecord(id=Environment.azienda)
# pbar(self.pbar_report,parziale=daos.index(ragsoc), totale=len(nomi), text=ragsoc, noeta=False)
#pbar(self.pbar_report,parziale=1, totale=4)
if hasattr(self._anagrafica,"funzione_ordinamento") and self._anagrafica.funzione_ordinamento == "cliforn":
if self._anagrafica.aa < 0:
daos.sort(key=lambda x: x.intestatario.strip().upper())
else:
daos.sort(key=lambda x: x.intestatario.strip().upper(),reverse=True)
elif hasattr(self._anagrafica,"funzione_ordinamento") and self._anagrafica.funzione_ordinamento == "impo":
for t in daos:
try:
t._totaleImponibileScontato
except:
t.totali
if self._anagrafica.aa < 0:
daos.sort(key=lambda x: x._totaleImponibileScontato)
else:
daos.sort(key=lambda x: x._totaleImponibileScontato,reverse=True)
self.numRecords = self.bodyWidget.countFilterResults(
self._filterCountClosure,
)
# self._refreshPageCount()
#pbar(self.pbar_report,parziale=2, totale=4)
pageData = {}
self.html_code = "<html><body></body></html>"
if self._tipo == "veter":
daos = daos[:]
da = []
for d in daos:
c = []
for a in d.righe:
if "TRIPLICE" in a.rig.arti.denominazione_famiglia:
c.append(a)
if len(c)>0:
da.append(d)
daos = da
elif self._tipo == "massa":
daos=daos[:]
articoli_dict = {}
if daos:
cliente = daos[0].CLI
else:
cliente = None
for d in daos:
for x in d.righe:
if x.id_articolo:
if x.rig.arti.APADR and (x.rig.arti.APADR.percentuale_carbonio or
x.rig.arti.APADR.percentuale_cov or
x.rig.arti.APADR.percentuale_secco):
a_adr = x.rig.arti
# print(a_adr)
if a_adr in articoli_dict:
articoli_dict[a_adr] += ( x.quantita*x.moltiplicatore )
else:
articoli_dict[a_adr] = (
x.quantita * x.moltiplicatore )
print(self._anagrafica.filter)
daData = self._anagrafica.filter.daData
aData = self._anagrafica.filter.aData
pageData = {
"file" : "report_massa.html",
"rows": articoli_dict,
"azienda":azienda,
"cliente":cliente,
"daData":daData,
"aData":aData,
"daos":daos,
}
self.html_code = renderTemplate(pageData)
try:
renderHTML(self.print_on_screen_html, str(self.html_code))
except:
renderHTML(self.print_on_screen_html, self.html_code)
return
#pbar(self.pbar_report,parziale=2.5, totale=4)
if daos:
pageData = {
"file": self._previewTemplate[1],
#"dao":daos,
"objects": daos,
"azienda" : azienda,
}
self.html_code = renderTemplate(pageData)
#pbar(self.pbar_report,parziale=3.75, totale=4)
#pbar(self.pbar_report,stop=True)
#self.pbar_dialog.hide()
try:
renderHTML(self.print_on_screen_html, str(self.html_code))
except:
renderHTML(self.print_on_screen_html, self.html_code)
def refreshHtml(self, dao=None):
self.html = renderTemplate(self.pageData)
renderHTML(self.detail, self.html)
def _setHtmlHandler(self, htmlHandler):
self.htmlHandler = htmlHandler
html = """<html><body></body></html>"""
renderHTML(self.html, html)
