def on_confirms_button_clicked(self, button):
        if self.data_listino_duplicato_entry.get_text() == '':
            obligatoryField(self.getTopLevel(),
                            self.data_listino_duplicato_entry)
        if (self.nome_listino_entry.get_text() == ''):
            obligatoryField(self.getTopLevel(),
                            self.nome_listino_entry)
        if (self.descrizione_listino_entry.get_text() == ''):
            obligatoryField(self.getTopLevel(),
                            self.descrizione_listino_entry)

        tutto = self.tutto_duplicato_check.get_active()
        tieni_data = self.tieni_data_check.get_active()
        sconto = self.duplica_listini_scontowidget.get_text()
        tiposconto = self.duplica_listini_scontowidget.tipoSconto
        plus = self.plus_radio.get_active()

        # Controllo eventuali listini con stessa coppia denominazione e data
        _denominazione = self.nome_listino_entry.get_text()
        _data = stringToDate(self.data_listino_duplicato_entry.get_text())
        _dataOra = stringToDateTime(self.data_listino_duplicato_entry.get_text())
        if _denominazione and _data:
            check = Listino().select(denominazione=_denominazione,
                                     dataListino=_dataOra,
                                     batchSize=None)

            if check:
                if len(check) > 0:
                    messageWarning(msg='Il listino è già presente.')
                    return

        newDao = Listino()
        newDao.data_listino = _data
        newDao.denominazione = _denominazione
        newDao.descrizione = self.descrizione_listino_entry.get_text()
        if tutto:
            newDao.listino_attuale = True
            newDao.visible = True
        newDao.visible = True
        newDao.persist()

        lcc = ListinoCategoriaCliente().select(idListino=self.dao.id,
                                                        batchSize=None)
        if lcc:
            for l in lcc:
                lccdao = ListinoCategoriaCliente()
                lccdao.id_listino = newDao.id
                lccdao.id_categoria_cliente = l.id_categoria_cliente
                lccdao.persist()

        lcl = ListinoComplessoListino().select(idListino=self.dao.id,
                                                            batchSize=None)
        if lcl:
            for l in lcl:
                lcldao = ListinoComplessoListino()
                lcldao.id_listino = newDao.id
                lcldao.id_listino_complesso = l.id_listino_complesso
                lcldao.persist()

        lm = ListinoMagazzino().select(idListino=self.dao.id, batchSize=None)
        if lm:
            for l in lm:
                lmdao = ListinoMagazzino()
                lmdao.id_listino = newDao.id
                lmdao.id_magazzino = l.id_magazzino
                lmdao.persist()

        la = ListinoArticolo().select(idListino= self.dao.id, batchSize=None)
        if la:
            for l in la:
                ladao = ListinoArticolo()
                ladao.id_listino = newDao.id
                ladao.id_articolo = l.id_articolo

                if not l.prezzo_dettaglio:
                    l.prezzo_dettaglio = Decimal('0.00')
                if not l.prezzo_ingrosso:
                    l.prezzo_ingrosso = Decimal('0.00')

                if sconto:
                    if tiposconto == "percentuale":
                        if plus:
                            ladao.prezzo_dettaglio = l.prezzo_dettaglio + (l.prezzo_dettaglio * Decimal(sconto) / 100)
                            ladao.prezzo_ingrosso = l.prezzo_ingrosso +(l.prezzo_ingrosso * Decimal(sconto) / 100)
#                            ladao.ultimo_costo = l.ultimo_costo + (l.ultimo_costo * Decimal(sconto) / 100)
                        else:
                            ladao.prezzo_dettaglio = l.prezzo_dettaglio - (l.prezzo_dettaglio * Decimal(sconto) / 100)
                            ladao.prezzo_ingrosso = l.prezzo_ingrosso -(l.prezzo_ingrosso * Decimal(sconto) / 100)
#                            ladao.ultimo_costo = l.ultimo_costo -(l.ultimo_costo * Decimal(sconto) / 100)
                    else:
                        if plus:
                            ladao.prezzo_dettaglio = l.prezzo_dettaglio + Decimal(sconto)
                            ladao.prezzo_ingrosso = l.prezzo_ingrosso + Decimal(sconto)
#                            ladao.ultimo_costo = l.ultimo_costo + Decimal(sconto)
                        else:
                            ladao.prezzo_dettaglio = l.prezzo_dettaglio - Decimal(sconto)
                            ladao.prezzo_ingrosso = l.prezzo_ingrosso - Decimal(sconto)
#                            ladao.ultimo_costo = l.ultimo_costo - Decimal(sconto)
                else:
                    ladao.prezzo_dettaglio = l.prezzo_dettaglio
                    ladao.prezzo_ingrosso = l.prezzo_ingrosso
                ladao.ultimo_costo = l.ultimo_costo
                if tieni_data:
                    ladao.data_listino_articolo = l.data_listino_articolo
                else:
                    ladao.data_listino_articolo = datetime.datetime.now()
                ladao.listino_attuale = True
                ladao.visible = True
                Environment.session.add(ladao)
                Environment.session.commit()

        messageInfo(msg="Nuovo Listino creato")

        self.destroy()
def listino_magazzino_table(soup=None, op=None, dao=None, row=None,all=False):
    d = None
    if soup and not all:
        record = soup.listino_magazzino.get(loads(row.object))
    else:
        record = row
    if op =="DELETE":
        if all:
            d = ListinoMagazzino().getRecord(id=[row.id_listino,row.id_magazzino])
        else:
            d = ListinoMagazzino().getRecord(id=loads(row.object))
        if d:
            d.delete()
        return True
    elif op == "INSERT":
        if all:
            d = ListinoMagazzino()
            d.id_listino = record.id_listino
            d.id_magazzino = record.id_magazzino
        else:
            d = ListinoArticolo().getRecord(id=loads(row.object))
    elif op == "UPDATE":
        if all:
            d = ListinoArticolo().getRecord(id=[row.id_listino,row.id_magazzino])
            #if d:
                #d = d[0]
        else:
            d = ListinoArticolo().getRecord(id=loads(row.object))
    d.persist()
    return True
    def saveDao(self, tipo=None):
        if (self.denominazione_entry.get_text() == ''):
            obligatoryField(self.dialogTopLevel, self.denominazione_entry)

        if (self.descrizione_entry.get_text() == ''):
            obligatoryField(self.dialogTopLevel, self.descrizione_entry)

        if (self.data_listino_entry.get_text() == ''):
            obligatoryField(self.dialogTopLevel, self.data_listino_entry)

        self.dao.denominazione = self.denominazione_entry.get_text()
        listinoAtt = Listino().select(denominazione=self.dao.denominazione)
        if not listinoAtt:
            self.dao.listino_attuale = True
        else:
            for l in listinoAtt:
                l.listino_attuale = False
                l.persist()
            self.dao.listino_attuale = True

        self.dao.descrizione = self.descrizione_entry.get_text()
        self.dao.data_listino = stringToDate(self.data_listino_entry.get_text())
        self.dao.visible = self.visible_check.get_active()
        self.dao.persist()
        cleanListinoCategoriaCliente = ListinoCategoriaCliente()\
                                            .select(idListino=self.dao.id,
                                            batchSize=None)
        for lcc in cleanListinoCategoriaCliente:
            lcc.delete()
        for c in self.categorie_listore:
            if c[3] == 'deleted':
                pass
            else:
                daoListinoCategoriaCliente = ListinoCategoriaCliente()
                daoListinoCategoriaCliente.id_listino = self.dao.id
                daoListinoCategoriaCliente.id_categoria_cliente = c[0]
                daoListinoCategoriaCliente.persist()

        cleanMagazzini = ListinoMagazzino()\
                                            .select(idListino=self.dao.id,
                                            batchSize=None)
        for mag in cleanMagazzini:
            mag.delete()
        for m in self.magazzino_listore:
            if m[3] != 'deleted':
                daoListinoMagazzino = ListinoMagazzino()
                daoListinoMagazzino.id_listino = self.dao.id
                daoListinoMagazzino.id_magazzino = m[0]
                daoListinoMagazzino.persist()

        cleanListini = ListinoComplessoListino().select(idListinoComplesso=self.dao.id,
                                                        batchSize=None)
        #print "CLEAN LISTINI", cleanListini
        for lis in cleanListini:
            Environment.session.delete(lis)
        Environment.session.commit()
        for l in self.listino_complesso_listore:
            if l[3] != 'deleted':
                daoListinoComplessoListino = ListinoComplessoListino()
                daoListinoComplessoListino.id_listino_complesso = self.dao.id
                daoListinoComplessoListino.id_listino = l[0]
                daoListinoComplessoListino.persist()

        #self.dao.persist()

        self._refreshCategorieClienti()
        self._refreshMagazzini()
        self._refreshListiniComplessi()