示例#1
0
def listino_table(soup=None, op=None, dao=None, row=None, all=False):
    d = None
    if soup and not all:
        record = soup.listino.get(loads(row.object))
    else:
        record = row
    if op =="DELETE":
        if all:
            d = Listino().getRecord(id=[row.denominazione,row.data_listino])
        else:
            d = Listino().getRecord(id=loads(row.object))
        if d:
            d.delete()
        return True
    elif op == "INSERT":
        if all:
            d = Listino()
            d.id = record.id
        else:
            d = Listino().getRecord(id=loads(row.object))
    elif op == "UPDATE":
        if all:
            d = Listino().select(id=row.id)
            if d:
                d = d[0]
        else:
            d = Listino().getRecord(id=loads(row.object))
    d.denominazione = record.denominazione
    d.descrizione = record.descrizione
    d.data_listino= record.data_listino
    d.listino_attuale = record.listino_attuale
    d.visible= record.visible
    d.persist()
    return True
 def setDao(self, dao):
     self.dao = dao
     if dao is None:
         self.dao = Listino()
     self._refresh()
     return self.dao
    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()
class AnagraficaListiniEdit(AnagraficaEdit):
    """ Modifica un record dell'anagrafica dei listini """

    def __init__(self, anagrafica):
        AnagraficaEdit.__init__(self,
                                  anagrafica,
                                  'Dati pagamento',
                                  root='anagrafica_listini_detail_table',
                                  path='_anagrafica_listini_elements.glade')
        self._widgetFirstFocus = self.denominazione_entry
        add_image =self.add_image.get_stock()
        self.addpix = self.add_image.render_icon(add_image[0],add_image[1], None)
        remove_image =self.remove_image.get_stock()
        self.removepix = self.remove_image.render_icon(remove_image[0],remove_image[1], None)

    def draw(self, cplx=False):
        #Elenco categorie
        fillComboboxCategorieClienti(self.id_categoria_cliente_customcombobox.combobox)
        self.id_categoria_cliente_customcombobox.connect('clicked',
                    on_id_categoria_cliente_customcombobox_clicked)
        fillComboboxMagazzini(self.id_magazzino_customcombobox.combobox)
        self.id_magazzino_customcombobox.connect('clicked',
                    on_id_magazzino_customcombobox_clicked)
        fillComboboxListini(self.id_listino_customcombobox.combobox)
        self.id_listino_customcombobox.connect('clicked',
                    on_id_listino_customcombobox_clicked)

    def setDao(self, dao):
        self.dao = dao
        if dao is None:
            self.dao = Listino()
        self._refresh()
        return self.dao

    def _refresh(self):
        self.denominazione_entry.set_text(self.dao.denominazione or '')
        self.descrizione_entry.set_text(self.dao.descrizione or '')
        self.data_listino_entry.set_text(dateToString(self.dao.data_listino))
        if self.dao.visible is None:
            self.visible_check.set_active(True)
        else:
            self.visible_check.set_active(self.dao.visible)
        self._refreshCategorieClienti()
        self._refreshMagazzini()
        self._refreshListiniComplessi()

    def _refreshCategorieClienti(self):
        self.id_categoria_cliente_customcombobox.combobox.set_active(-1)
        model = self.categorie_treeview.get_model()
        model.clear()
        if not self.dao.id:
            return
        categorie = self.dao.categorieCliente
        for c in categorie:
            model.append((c.id_categoria_cliente, c.categoria_cliente, None, None))

    def _refreshMagazzini(self):
        self.id_magazzino_customcombobox.combobox.set_active(-1)
        model = self.magazzini_treeview.get_model()
        model.clear()
        if not self.dao.id:
            return
        magazzini = self.dao.magazzini
        for m in magazzini:
            model.append((m.id_magazzino, m.magazzino, None, None))

    def _refreshListiniComplessi(self):
        self.id_listino_customcombobox.combobox.set_active(-1)
        model = self.listino_complesso_treeview.get_model()
        model.clear()
        if not self.dao.id:
            return
        listini = self.dao.listiniComplessi
        for m in listini:
            model.append((m.id_listino, m.listino_denominazione, None, None))

    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()

    def on_add_row_categoria_button_clicked(self, widget):
        id = findIdFromCombobox(self.id_categoria_cliente_customcombobox.combobox)
        if id is not None:
            categoria = findStrFromCombobox(self.id_categoria_cliente_customcombobox.combobox, 2)
            for c in self.categorie_listore:
                if c[0] == id:
                    return
            self.categorie_listore.append((id, categoria, self.addpix, 'added'))
        self.categorie_treeview.get_selection().unselect_all()

    def on_add_row_magazzino_button_clicked(self, widget):
        id = findIdFromCombobox(self.id_magazzino_customcombobox.combobox)
        if id:
            magazzino = findStrFromCombobox(self.id_magazzino_customcombobox.combobox, 2)
            for m in self.magazzino_listore:
                if m[0] == id:
                    return
            self.magazzino_listore.append((id, magazzino, self.addpix, 'added'))
        self.magazzini_treeview.get_selection().unselect_all()

    def on_add_row_listino_complesso_button_clicked(self, widget):
        id = findIdFromCombobox(self.id_listino_customcombobox.combobox)
        if id:
            listino = findStrFromCombobox(self.id_listino_customcombobox.combobox, 2)
            for m in self.listino_complesso_listore:
                if m[0] == id:
                    return
            self.listino_complesso_listore.append((id, listino, self.addpix, 'added'))
        self.listino_complesso_treeview.get_selection().unselect_all()

    def on_delete_row_categoria_button_clicked(self, widget):
        id = findIdFromCombobox(
                        self.id_categoria_cliente_customcombobox.combobox)
        if id:
            for c in self.categorie_listore:
                if c[0] == id:
                    if c[2] is None:
                        c[2] = self.removepix
                        c[3] = 'deleted'
                    else:
                        self.categorie_listore.remove(c.iter)
        self.categorie_treeview.get_selection().unselect_all()

    def on_delete_row_magazzino_button_clicked(self, widget):
        id = findIdFromCombobox(self.id_magazzino_customcombobox.combobox)
        if id:
            for m in self.magazzino_listore:
                if m[0] == id:
                    if m[2] is None:
                        m[2] = self.removepix
                        m[3] = 'deleted'
                    else:
                        self.magazzini_listore.remove(m.iter)
        self.magazzini_treeview.get_selection().unselect_all()

    def on_delete_row_listino_complesso_button_clicked(self, widget):
        id = findIdFromCombobox(self.id_listino_customcombobox.combobox)
        if id:
            for m in self.listino_complesso_listore:
                if m[0] == id:
                    if m[2] is None:
                        m[2] = self.removepix
                        m[3] = 'deleted'
                    else:
                        self.listino_complesso_listore.remove(m.iter)
        self.listino_complesso_treeview.get_selection().unselect_all()

    def on_undelete_row_categoria_button_clicked(self, widget):
        id = findIdFromCombobox(
                        self.id_categoria_cliente_customcombobox.combobox)
        if id:
            for c in self.categorie_listore:
                if c[0] == id:
                    if c[3] == 'deleted':
                        c[2] = None
                        c[3] = None
        self.categorie_treeview.get_selection().unselect_all()

    def on_undelete_row_magazzino_button_clicked(self, widget):
        id = findIdFromCombobox(self.id_magazzino_customcombobox.combobox)
        if id:
            for m in self.magazzini_listore:
                if m[0] == id:
                    if m[3] == 'deleted':
                        m[2] = None
                        m[3] = None
        self.magazzini_treeview.get_selection().unselect_all()

    def on_undelete_row_listino_complesso_button_clicked(self, widget):
        id = findIdFromCombobox(self.id_listino_customcombobox.combobox)
        if id:
            for m in self.listino_complesso_listore:
                if m[0] == id:
                    if m[3] == 'deleted':
                        m[2] = None
                        m[3] = None
        self.listino_complesso_treeview.get_selection().unselect_all()

    def on_categorie_treeview_cursor_changed(self, treeview):
        sel = treeview.get_selection()
        (model, iterator) = sel.get_selected()
        if iterator is not None:
            idCategoriaCliente = model.get_value(iterator, 0)
            findComboboxRowFromId(
                self.id_categoria_cliente_customcombobox.combobox,
                idCategoriaCliente)
            status = model.get_value(iterator, 3)
            self.delete_row_categoria_button.set_sensitive(status != 'deleted')
            self.undelete_row_categoria_button.set_sensitive(
                                                        status == 'deleted')

    def on_magazzini_treeview_cursor_changed(self, treeview):
        sel = treeview.get_selection()
        (model, iterator) = sel.get_selected()
        if iterator is not None:
            idMagazzino = model.get_value(iterator, 0)
            findComboboxRowFromId(self.id_magazzino_customcombobox.combobox,
                                                         idMagazzino)
            status = model.get_value(iterator, 3)
            self.delete_row_magazzino_button.set_sensitive(status != 'deleted')
            self.undelete_row_magazzino_button.set_sensitive(
                                                        status == 'deleted')

    def on_listino_complesso_treeview_cursor_changed(self, treeview):
        sel = treeview.get_selection()
        (model, iterator) = sel.get_selected()
        if iterator is not None:
            idListino = model.get_value(iterator, 0)
            findComboboxRowFromId(self.id_listino_customcombobox.combobox,
                                                             idListino)
            status = model.get_value(iterator, 3)
            self.delete_listino_button.set_sensitive(status != 'deleted')
            self.undelete_listino_button.set_sensitive(status == 'deleted')

    def on_listini_articoli_togglebutton_clicked(self, toggleButton):
        if not(toggleButton.get_active()):
            toggleButton.set_active(False)
            return

        if self.dao.id is None:
            msg = 'Prima di poter inserire gli articoli occorre salvare il listino.\n Salvare ?'
            if YesNoDialog(msg=msg, transient=self.dialogTopLevel):
                self.on_anagrafica_complessa_detail_dialog_response(
                                self.dialogTopLevel,
                                GTK_RESPONSE_APPLY)
            else:
                toggleButton.set_active(False)
                return

        from AnagraficaListiniArticoli import AnagraficaListiniArticoli
        anag = AnagraficaListiniArticoli(idListino=self.dao.id)
        anagWindow = anag.getTopLevel()
        showAnagraficaRichiamata(self.dialogTopLevel, anagWindow, toggleButton)

    def on_variazioni_togglebutton_toggled(self, toggleButton):
        if toggleButton.get_active():
            anag = AnagraficaVariazioniListini(idListino=self.dao.id)
            anagWindow = anag.getTopLevel()
            showAnagraficaRichiamata(self.dialogTopLevel, anagWindow, toggleButton)
        else:
            toggleButton.set_active(False)

    def on_check_pricelist_togglebutton_toggled(self, toggleButton):
        if not(toggleButton.get_active()):
            toggleButton.set_active(False)
            return

        if self.dao.id is None:
            msg = 'Prima di poter filtrare gli articoli occorre salvare il listino.\n Salvare ?'
            if YesNoDialog(msg=msg, transient=self.dialogTopLevel):
                self.on_anagrafica_complessa_detail_dialog_response(
                                self.dialogTopLevel,
                                GTK_RESPONSE_APPLY)
            else:
                toggleButton.set_active(False)
                return

        from CrossFilterPriceList import CrossFilterPriceList
        anag = CrossFilterPriceList(listino=self.dao)
        anagWindow = anag.getTopLevel()

        showAnagraficaRichiamata(self.dialogTopLevel, anagWindow, toggleButton)