Example #1
0
    def Modifier(self, event):
        if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "individus_scolarite", "modifier") == False:
            return
        if len(self.Selection()) == 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous n'avez sélectionné aucune étape de scolarité à modifier dans la liste"
                  ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        IDscolarite = self.Selection()[0].IDscolarite
        date_debut = self.Selection()[0].dateDebutDD
        date_fin = self.Selection()[0].dateFinDD
        IDecole = self.Selection()[0].IDecole
        IDclasse = self.Selection()[0].IDclasse
        IDniveau = self.Selection()[0].IDniveau

        from Dlg import DLG_Saisie_scolarite
        dlg = DLG_Saisie_scolarite.Dialog(self,
                                          IDscolarite=IDscolarite,
                                          donneesScolarite=self.donnees)
        dlg.SetTitle(_(u"Modification d'une étape de la scolarité"))
        dlg.SetDateDebut(date_debut)
        dlg.SetDateFin(date_fin)
        dlg.SetEcole(IDecole)
        dlg.SetClasse(IDclasse)
        dlg.SetNiveau(IDniveau)
        if dlg.ShowModal() == wx.ID_OK:
            date_debut = dlg.GetDateDebut()
            date_fin = dlg.GetDateFin()
            IDecole = dlg.GetEcole()
            IDclasse = dlg.GetClasse()
            IDniveau = dlg.GetNiveau()
            nomEcole = dlg.GetNomEcole()
            nomClasse = dlg.GetNomClasse()
            nomNiveau = dlg.GetNomNiveau()

            # Sauvegarde
            DB = GestionDB.DB()
            listeDonnees = [
                ("date_debut", date_debut),
                ("date_fin", date_fin),
                ("IDecole", IDecole),
                ("IDclasse", IDclasse),
                ("IDniveau", IDniveau),
            ]
            DB.ReqMAJ("scolarite", listeDonnees, "IDscolarite", IDscolarite)
            DB.Close()

            # Mémorise l'action dans l'historique
            UTILS_Historique.InsertActions([
                {
                    "IDindividu":
                    self.IDindividu,
                    "IDfamille":
                    None,
                    "IDcategorie":
                    31,
                    "action":
                    _(u"Inscription scolaire du %s au %s. Ecole : '%s'. Classe : '%s'. Niveau : '%s'"
                      ) % (DateEngFr(str(date_debut)), DateEngFr(
                          str(date_fin)), nomEcole, nomClasse, nomNiveau)
                },
            ])

            # Actualise l'affichage
            self.MAJ(IDscolarite)
        dlg.Destroy()
Example #2
0
    def Supprimer(self, event):
        if self.IDcompte_payeur != None and UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "familles_factures", "supprimer") == False:
            return
        if self.IDcompte_payeur == None and UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "facturation_factures", "supprimer") == False:
            return

        # Avertissements
        if len(self.Selection()) == 0 and len(self.GetTracksCoches()) == 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous n'avez sélectionné aucune facture dans la liste !"),
                _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        # Choix entre Suppression et Annulation
        from Dlg import DLG_Supprimer_facture
        dlg = DLG_Supprimer_facture.Dialog(self)
        reponse = dlg.ShowModal()
        dlg.Destroy()
        if reponse == 100:
            mode = "annulation"
            verbe = "annuler"
        elif reponse == 200:
            mode = "suppression"
            verbe = "supprimer"
        else:
            return False

        # Demande de confirmation
        if len(self.GetTracksCoches()) > 0:
            # Suppression multiple
            listeSelections = self.GetTracksCoches()
            dlg = wx.MessageDialog(
                self,
                _(u"Souhaitez-vous vraiment %s les %d factures cochées ?") %
                (verbe, len(listeSelections)), _(u"Confirmation"),
                wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
            reponse = dlg.ShowModal()
            dlg.Destroy()
            if reponse != wx.ID_YES:
                return

        else:
            # Suppression unique
            listeSelections = self.Selection()
            dlg = wx.MessageDialog(
                self,
                _(u"Souhaitez-vous vraiment %s la facture n°%s ?") %
                (verbe, listeSelections[0].numero), _(u"Confirmation"),
                wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
            reponse = dlg.ShowModal()
            dlg.Destroy()
            if reponse != wx.ID_YES:
                return

        # Suppression de la facture
        listeIDfactures = []
        for track in listeSelections:
            listeIDfactures.append(track.IDfacture)

        from Utils import UTILS_Facturation
        UTILS_Facturation.SuppressionFacture(listeIDfactures, mode=mode)

        # MAJ du listeView
        self.MAJ()
Example #3
0
    def Validation(self):
        """ Validation des données saisies """
        # Vérifie date début
        date_debut = self.ctrl_date_debut.GetDate()
        if self.ctrl_date_debut.FonctionValiderDate(
        ) == False or date_debut == None:
            dlg = wx.MessageDialog(
                self,
                _(u"La date de début de période ne semble pas valide !"),
                _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            self.ctrl_date_debut.SetFocus()
            return False

        # Vérifie date fin
        date_fin = self.ctrl_date_fin.GetDate()
        if self.ctrl_date_fin.FonctionValiderDate(
        ) == False or date_fin == None:
            dlg = wx.MessageDialog(
                self, _(u"La date de fin de période ne semble pas valide !"),
                _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            self.ctrl_date_fin.SetFocus()
            return False

        # Vérifie les deux dates
        if date_debut > date_fin:
            dlg = wx.MessageDialog(
                self,
                _(u"La date de début de période est supérieure à la date de fin !"
                  ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            self.ctrl_date_fin.SetFocus()
            return False

        # Vérifie que la période sélectionnée n'est pas dans une période de gestion
        gestion = UTILS_Gestion.Gestion(None)
        if gestion.IsPeriodeinPeriodes("factures", date_debut,
                                       date_fin) == False:
            return False

        # Vérifier si lot de factures
        IDlot = self.ctrl_lot.GetID()
        nomLot = self.ctrl_lot.GetNom()
        if IDlot == None:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous n'avez pas sélectionné de lot de factures à associer.\n\nSouhaitez-vous quand même continuer ?"
                  ), _(u"Confirmation"),
                wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_EXCLAMATION)
            resultat = dlg.ShowModal()
            dlg.Destroy()
            if resultat != wx.ID_YES:
                return False

        # Préfixe de facture
        IDprefixe = self.ctrl_prefixe.GetID()
        prefixe = self.ctrl_prefixe.GetPrefixe()

        # Prochain numéro de facture
        if self.check_numero_auto.GetValue() == True:
            # Numéro auto
            prochain_numero = None
        else:
            # Numéro perso
            try:
                prochain_numero = int(self.ctrl_prochain_numero.GetValue())
            except:
                prochain_numero = None
            if prochain_numero in (None, ""):
                dlg = wx.MessageDialog(
                    self,
                    _(u"Le prochain numéro de facture ne semble pas valide !"
                      ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
                self.ctrl_prochain_numero.SetFocus()
                return False

            if prochain_numero < self.prochain_numero_defaut:
                dlg = wx.MessageDialog(
                    self,
                    _(u"Le prochain numéro de facture n'est pas valide : une facture générée porte déjà un numéro égal ou supérieur !"
                      ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
                self.ctrl_prochain_numero.SetFocus()
                return False

        # Date d'émission
        date_emission = self.ctrl_date_emission.GetDate()
        if self.ctrl_date_emission.FonctionValiderDate(
        ) == False or date_emission == None:
            dlg = wx.MessageDialog(
                self, _(u"La date d'émission ne semble pas valide !"),
                _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            self.ctrl_date_emission.SetFocus()
            return False

        # Date d'échéance
        date_echeance = self.ctrl_date_echeance.GetDate()
        if date_echeance == None:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous n'avez pas saisi de date d'échéance. \n\nSouhaitez-vous quand même continuer ?"
                  ), _(u"Confirmation"),
                wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_EXCLAMATION)
            resultat = dlg.ShowModal()
            dlg.Destroy()
            if resultat != wx.ID_YES:
                return False

        # Vérifier si lot de factures
        prestations = []
        if self.check_consommations.GetValue() == True:
            prestations.append("consommation")
        if self.check_cotisations.GetValue() == True:
            prestations.append("cotisation")
        if self.check_locations.GetValue() == True:
            prestations.append("location")
        if self.check_autres.GetValue() == True: prestations.append("autre")
        if len(prestations) == 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous devez obligatoirement cocher au moins un type de prestation à facturer !"
                  ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return False

        # Familles
        if self.radio_familles_toutes.GetValue() == True:
            IDcompte_payeur_unique = None
        else:
            IDcompte_payeur_unique = self.ctrl_famille.GetIDcompte_payeur()
            if IDcompte_payeur_unique == None:
                dlg = wx.MessageDialog(
                    self,
                    _(u"Vous avez sélectionné l'option 'famille unique' mais sans sélectionner de famille dans la liste proposée !"
                      ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
                return False

        # Vérifie les activités sélectionnées
        listeActivites = self.ctrl_activites.GetActivites()
        if len(listeActivites) == 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous n'avez sélectionné aucune activité.\n\nSouhaitez-vous quand même continuer ?"
                  ), _(u"Avertissement"),
                wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_EXCLAMATION)
            resultat = dlg.ShowModal()
            dlg.Destroy()
            if resultat != wx.ID_YES:
                return False

        # Date antérieure
        date_anterieure = None
        if self.check_prestations_anterieures.GetValue() == True:
            date_anterieure = self.ctrl_date_anterieures.GetDate()
            if self.ctrl_date_anterieures.FonctionValiderDate(
            ) == False or date_anterieure == None:
                dlg = wx.MessageDialog(
                    self, _(u"La date antérieure ne semble pas valide !"),
                    _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
                self.ctrl_date_anterieures.SetFocus()
                return False

        # Vérification droits utilisateurs
        for IDactivite in listeActivites:
            if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                    "facturation_factures",
                    "creer",
                    IDactivite=IDactivite,
                    afficheMessage=False) == False:
                dlg = wx.MessageDialog(
                    self,
                    _(u"Vous n'avez pas l'autorisation de générer des factures pour l'ensemble des activités sélectionnées !"
                      ), _(u"Action non autorisée"),
                    wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
                return False

        # Vérifie la compatibilité des régies des activités sélectionnées
        IDregie = None
        if len(listeActivites) >= 1:
            listeAllRegies = []
            for IDactivite in listeActivites:
                DB = GestionDB.DB()
                req = """SELECT regie
                FROM activites
                WHERE IDactivite = %d""" % IDactivite
                DB.ExecuterReq(req)
                listeresult = DB.ResultatReq()
                result = listeresult[0]
                listeAllRegies.append(result[0])
                DB.Close()
            listeRegies = list(set(listeAllRegies))
            if len(listeRegies) > 1:
                dlg = wx.MessageDialog(
                    self,
                    _(u"Vous ne pouvez pas générer des factures pour l'ensemble des activités sélectionnées !\n\nCertaines activités sont liées à des régies différentes"
                      ), _(u"Régies différentes"),
                    wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
                return False
            else:
                IDregie = listeRegies[0]

        # Envoi des données à DLG_Factures_generation
        self.parent.dictParametres = {
            "date_debut": date_debut,
            "date_fin": date_fin,
            "IDlot": IDlot,
            "nomLot": nomLot,
            "date_emission": date_emission,
            "date_echeance": date_echeance,
            "prochain_numero": prochain_numero,
            "prestations": prestations,
            "IDcompte_payeur": IDcompte_payeur_unique,
            "listeActivites": listeActivites,
            "IDprefixe": IDprefixe,
            "prefixe": prefixe,
            "date_anterieure": date_anterieure,
            "IDregie": IDregie,
        }

        return True
Example #4
0
    def Supprimer(self, event):
        if len(self.Selection()) == 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous n'avez sélectionné aucune inscription à supprimer dans la liste"
                  ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        IDinscription = self.Selection()[0].IDinscription
        IDfamille = self.Selection()[0].IDfamille
        IDindividu = self.Selection()[0].IDindividu
        nomActivite = self.Selection()[0].nom_activite
        IDactivite = self.Selection()[0].IDactivite

        # Verrouillage utilisateurs
        if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "individus_inscriptions", "supprimer",
                IDactivite=IDactivite) == False:
            return

        DB = GestionDB.DB()

        # Recherche si des consommations existent
        req = """SELECT IDconso, date, forfait
        FROM consommations
        WHERE IDinscription=%d AND (forfait IS NULL OR forfait=1);""" % IDinscription
        DB.ExecuterReq(req)
        listeDonnees = DB.ResultatReq()
        listeConso = []
        for IDconso, date, forfait in listeDonnees:
            date = UTILS_Dates.DateEngEnDateDD(date)
            listeConso.append({
                "IDconso": IDconso,
                "date": date,
                "forfait": forfait
            })
        if len(listeConso) > 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Il existe déjà %d consommations enregistrées sur cette inscription. \n\nIl est donc impossible de la supprimer !"
                  ) % len(listeConso), _(u"Annulation impossible"),
                wx.OK | wx.ICON_ERROR)
            dlg.ShowModal()
            dlg.Destroy()
            DB.Close()
            return

        # Recherche si des prestations existent
        req = """SELECT IDprestation, prestations.date, prestations.forfait
        FROM prestations
        WHERE IDactivite=%d AND IDindividu=%d
        ;""" % (IDactivite, IDindividu)
        DB.ExecuterReq(req)
        listePrestations = DB.ResultatReq()
        listePrestationsForfait = []
        listePrestationsNormales = []
        listeDatesPrestations = []
        for IDprestation, date, forfait in listePrestations:
            listeDatesPrestations.append(UTILS_Dates.DateEngEnDateDD(date))
            if forfait == 2:
                if IDprestation not in listePrestationsForfait:
                    listePrestationsForfait.append(IDprestation)
            else:
                if IDprestation not in listePrestationsNormales:
                    listePrestationsNormales.append(IDprestation)
        if len(listePrestations) - len(listePrestationsForfait) > 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Il existe déjà %d prestations enregistrées sur cette inscription. \n\nIl est donc impossible de la supprimer !"
                  ) % len(listePrestations), _(u"Annulation impossible"),
                wx.OK | wx.ICON_ERROR)
            dlg.ShowModal()
            dlg.Destroy()
            DB.Close()
            return

        DB.Close()

        # Périodes de gestion
        self.gestion = UTILS_Gestion.Gestion(self)
        if self.gestion.Verification("consommations", listeConso) == False:
            return False
        if self.gestion.Verification("prestations",
                                     listeDatesPrestations) == False:
            return False

        # Demande de confirmation
        if len(listePrestationsForfait) == 0: texteForfait = u""
        elif len(listePrestationsForfait) == 1:
            texteForfait = _(
                u"\n\n(La prestation associée sera également supprimée)")
        else:
            texteForfait = _(
                u"\n\n(Les %d prestations associées seront également supprimées)"
            ) % len(listePrestationsForfait)
        dlg = wx.MessageDialog(
            self,
            _(u"Souhaitez-vous vraiment supprimer cette inscription ?%s") %
            texteForfait, _(u"Suppression"),
            wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
        if dlg.ShowModal() == wx.ID_YES:
            IDinscription = self.Selection()[0].IDinscription
            DB = GestionDB.DB()
            DB.ReqDEL("inscriptions", "IDinscription", IDinscription)
            # Suppression des forfaits associés déjà saisis
            for IDprestation in listePrestationsForfait:
                DB.ReqDEL("prestations", "IDprestation", IDprestation)
                DB.ReqDEL("consommations", "IDprestation", IDprestation)
                DB.ReqDEL("deductions", "IDprestation", IDprestation)
                DB.ReqDEL("ventilation", "IDprestation", IDprestation)
            DB.Close()

            # Mémorise l'action dans l'historique
            UTILS_Historique.InsertActions([
                {
                    "IDindividu":
                    self.IDindividu,
                    "IDfamille":
                    IDfamille,
                    "IDcategorie":
                    19,
                    "action":
                    _(u"Suppression de l'inscription à l'activité '%s'") %
                    nomActivite
                },
            ])

            # Actualise l'affichage
            self.MAJ()
        dlg.Destroy()
Example #5
0
    def OnBoutonActualiser(self, event):
        # Validation de la période
        date_debut = self.ctrl_date_debut.GetDate()
        if self.ctrl_date_debut.FonctionValiderDate(
        ) == False or date_debut == None:
            dlg = wx.MessageDialog(
                self, _(u"La date de début de période semble incorrecte !"),
                _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return False

        date_fin = self.ctrl_date_fin.GetDate()
        if self.ctrl_date_fin.FonctionValiderDate(
        ) == False or date_fin == None:
            dlg = wx.MessageDialog(
                self, _(u"La date de fin de période semble incorrecte !"),
                _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return False

        if date_fin < date_debut:
            dlg = wx.MessageDialog(
                self,
                _(u"La date de début de période est supérieure à la date de fin !"
                  ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return False

        # Validation de la date de naissance limite
        dateNaiss = None
        if self.check_dateNaiss.GetValue() == True:
            dateNaiss = self.ctrl_dateNaiss.GetValue()
            if self.ctrl_dateNaiss.FonctionValiderDate(
            ) == False or dateNaiss == None:
                dlg = wx.MessageDialog(
                    self, _(u"La date de naissance semble incorrecte !"),
                    _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
                self.ctrl_dateNaiss.SetFocus()
                return False
            else:
                dateNaiss = self.ctrl_dateNaiss.GetDate()

        # Validation des activités
        listeActivites = self.GetActivites()
        if len(listeActivites) == 0:
            dlg = wx.MessageDialog(
                self, _(u"Vous devez sélectionner au moins une activité !"),
                _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return False

        # Validation des modes de règlement
        listeModes = self.GetModes()
        if len(listeModes) == 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous devez sélectionner au moins un mode de règlement !"
                  ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return False

        # Vérification droits utilisateurs
        for IDactivite in listeActivites:
            if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                    "facturation_attestations",
                    "creer",
                    IDactivite=IDactivite,
                    afficheMessage=False) == False:
                dlg = wx.MessageDialog(
                    self,
                    _(u"Vous n'avez pas l'autorisation de générer des attestations pour l'ensemble des activités sélectionnées !"
                      ), _(u"Action non autorisée"),
                    wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
                return False

        # MAJ de la liste des prestations
        dlgAttente = wx.BusyInfo(_(u"Recherche des données..."), None)
        wx.Yield()
        try:
            self.MAJprestations()
            del dlgAttente
        except Exception, err:
            print err
            del dlgAttente
    def OnBoutonOk(self, event):
        # Validation de la période
        date_debut = self.ctrl_parametres.ctrl_date_debut.GetDate()
        if self.ctrl_parametres.ctrl_date_debut.FonctionValiderDate(
        ) == False or date_debut == None:
            dlg = wx.MessageDialog(
                self, _(u"La date de début de période semble incorrecte !"),
                _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        date_fin = self.ctrl_parametres.ctrl_date_fin.GetDate()
        if self.ctrl_parametres.ctrl_date_fin.FonctionValiderDate(
        ) == False or date_fin == None:
            dlg = wx.MessageDialog(
                self, _(u"La date de fin de période semble incorrecte !"),
                _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        if date_fin < date_debut:
            dlg = wx.MessageDialog(
                self,
                _(u"La date de début de période est supérieure à la date de fin !"
                  ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        # Validation de la date de naissance limite
        dateNaiss = None
        if self.ctrl_parametres.check_dateNaiss.GetValue() == True:
            dateNaiss = self.ctrl_parametres.ctrl_dateNaiss.GetValue()
            if self.ctrl_parametres.ctrl_dateNaiss.FonctionValiderDate(
            ) == False or dateNaiss == None:
                dlg = wx.MessageDialog(
                    self, _(u"La date de naissance semble incorrecte !"),
                    _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
                self.ctrl_parametres.ctrl_dateNaiss.SetFocus()
                return
            else:
                dateNaiss = self.ctrl_parametres.ctrl_dateNaiss.GetDate()

        # Validation des activités
        listeActivites = self.ctrl_parametres.GetActivites()
        if len(listeActivites) == 0:
            dlg = wx.MessageDialog(
                self, _(u"Vous devez sélectionner au moins une activité !"),
                _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        # Vérification droits utilisateurs
        for IDactivite in listeActivites:
            if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                    "facturation_attestations",
                    "creer",
                    IDactivite=IDactivite,
                    afficheMessage=False) == False:
                dlg = wx.MessageDialog(
                    self,
                    _(u"Vous n'avez pas l'autorisation de générer des attestations pour l'ensemble des activités sélectionnées !"
                      ), _(u"Action non autorisée"),
                    wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
                return False

        # Validation des prestations
        listePrestations = self.ctrl_prestations.GetDonnees()
        if len(listePrestations) == 0:
            dlg = wx.MessageDialog(
                self, _(u"Vous devez sélectionner au moins une prestation !"),
                _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        # Ouvrir la DLG de sélection
        dlg = DLG_Attestations_selection.Dialog(
            self,
            date_debut=date_debut,
            date_fin=date_fin,
            dateNaiss=dateNaiss,
            listeActivites=listeActivites,
            listePrestations=listePrestations)
        reponse = dlg.ShowModal()
        dlg.Destroy()

        if reponse == 200:
            self.EndModal(wx.ID_OK)
Example #7
0
    def Supprimer(self, event):
        if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "individus_fiche", "consulter") == False:
            return
        if len(self.Selection()) == 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous n'avez sélectionné aucun individu dans la liste"),
                _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return
        IDindividu = self.Selection()[0].IDindividu

        DB = GestionDB.DB()

        # Vérifie si cet individu n'est pas rattaché à une famille
        req = """
        SELECT IDrattachement, IDfamille
        FROM rattachements
        WHERE IDindividu=%d
        """ % IDindividu
        DB.ExecuterReq(req)
        listeDonnees = DB.ResultatReq()
        if len(listeDonnees) > 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous ne pouvez pas supprimer cette fiche car elle est rattachée à au moins une famille.\n\nSi vous souhaitez vraiment la supprimer, veuillez effectuer cette action à partir de la fiche famille !"
                  ), _(u"Suppression impossible"), wx.OK | wx.ICON_ERROR)
            dlg.ShowModal()
            dlg.Destroy()
            DB.Close()
            return False

        # Demande de confirmation
        dlg = wx.MessageDialog(
            self, _(u"Souhaitez-vous vraiment supprimer cet individu ?"),
            _(u"Confirmation de suppression"),
            wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
        if dlg.ShowModal() != wx.ID_YES:
            DB.Close()
            dlg.Destroy()
            return False
        dlg.Destroy()

        # Suppression : liens
        req = "DELETE FROM liens WHERE IDindividu_sujet=%d;" % IDindividu
        DB.ExecuterReq(req)
        req = "DELETE FROM liens WHERE IDindividu_objet=%d;" % IDindividu
        DB.ExecuterReq(req)

        # Suppression : vaccins
        req = "DELETE FROM vaccins WHERE IDindividu=%d;" % IDindividu
        DB.ExecuterReq(req)

        # Suppression : problemes_sante
        req = "DELETE FROM problemes_sante WHERE IDindividu=%d;" % IDindividu
        DB.ExecuterReq(req)

        # Suppression : abonnements
        req = "DELETE FROM abonnements WHERE IDindividu=%d;" % IDindividu
        DB.ExecuterReq(req)

        # Suppression : individu
        req = "DELETE FROM individus WHERE IDindividu=%d;" % IDindividu
        DB.ExecuterReq(req)

        DB.Commit()
        DB.Close()

        dlg = wx.MessageDialog(
            self, _(u"La fiche individuelle a été supprimée avec succès."),
            _(u"Suppression"), wx.OK | wx.ICON_INFORMATION)
        dlg.ShowModal()
        dlg.Destroy()

        self.MAJ()

        # MAJ du listView
        ##        self.MAJ()
        # MAJ du remplissage
        try:
            if self.GetGrandParent().GetName() == "general":
                self.GetGrandParent().MAJ()
##                self.GetGrandParent().ctrl_remplissage.MAJ()
            else:
                self.MAJ()

        except:
            pass
Example #8
0
    def OnBoutonOk(self, event):
        # Vérification des données saisies
        IDactivite = self.GetIDactivite()
        if IDactivite == None:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous devez obligatoirement sélectionner une activité !"),
                _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        IDgroupe = self.ctrl_groupes.GetID()
        if IDgroupe == None:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous devez obligatoirement sélectionner un groupe !"),
                _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        IDcategorie_tarif = self.ctrl_categories.GetID()
        if IDcategorie_tarif == None:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous devez obligatoirement sélectionner une catégorie de tarifs !"
                  ), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        # Verrouillage utilisateurs
        if self.mode == "saisie":
            action = "creer"
        else:
            action = "modifier"
        if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "individus_inscriptions", action,
                IDactivite=IDactivite) == False:
            return

        # Vérification du nombre d'inscrits max de l'activité
        if self.mode == "saisie" and self.dictActivite[
                "nbre_places_disponibles"] != None:
            if self.dictActivite["nbre_places_disponibles"] <= 0:
                dlg = wx.MessageDialog(
                    None,
                    _(u"Le nombre maximal d'inscrits autorisé pour cette activité (%d places max) a été atteint !\n\nSouhaitez-vous tout de même inscrire cet individu ?"
                      ) % self.dictActivite["nbre_inscrits_max"],
                    _(u"Nbre d'inscrit maximal atteint"), wx.YES_NO
                    | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_EXCLAMATION)
                reponse = dlg.ShowModal()
                dlg.Destroy()
                if reponse != wx.ID_YES:
                    return

        # Vérification du nombre d'inscrits max du groupe
        if IDgroupe != self.IDgroupe:
            for dictGroupe in self.dictActivite["groupes"]:
                if dictGroupe["IDgroupe"] == IDgroupe and dictGroupe[
                        "nbre_places_disponibles"] != None:
                    if dictGroupe["nbre_places_disponibles"] <= 0:
                        dlg = wx.MessageDialog(
                            None,
                            _(u"Le nombre maximal d'inscrits autorisé sur ce groupe (%d places max) a été atteint !\n\nSouhaitez-vous tout de même inscrire cet individu ?"
                              ) % dictGroupe["nbre_inscrits_max"],
                            _(u"Nbre d'inscrit maximal atteint"), wx.YES_NO
                            | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_EXCLAMATION)
                        reponse = dlg.ShowModal()
                        dlg.Destroy()
                        if reponse != wx.ID_YES:
                            return

        # Récupération autres variables
        IDfamille = self.ctrl_famille.GetID()
        nomActivite = self.ctrl_activite.GetNomActivite()
        nomGroupe = self.ctrl_groupes.GetStringSelection()
        nomCategorie = self.ctrl_categories.GetStringSelection()
        IDcompte_payeur = self.GetCompteFamille(IDfamille)
        parti = self.ctrl_parti.GetValue()

        DB = GestionDB.DB()

        # Vérifie que l'individu n'est pas déjà inscrit à cette activite
        if self.mode == "saisie":
            req = """SELECT IDinscription, IDindividu, IDfamille
            FROM inscriptions
            WHERE IDindividu=%d AND IDfamille=%d AND IDactivite=%d;""" % (
                self.IDindividu, IDfamille, IDactivite)
            DB.ExecuterReq(req)
            listeDonnees = DB.ResultatReq()
            if len(listeDonnees) > 0:
                DB.Close()
                dlg = wx.MessageDialog(
                    self,
                    _(u"Cet individu est déjà inscrit à l'activité '%s' !")
                    % nomActivite, _(u"Erreur de saisie"),
                    wx.OK | wx.ICON_ERROR)
                dlg.ShowModal()
                dlg.Destroy()
                return

        # Sauvegarde
        listeDonnees = [
            ("IDindividu", self.IDindividu),
            ("IDfamille", IDfamille),
            ("IDactivite", IDactivite),
            ("IDgroupe", IDgroupe),
            ("IDcategorie_tarif", IDcategorie_tarif),
            ("IDcompte_payeur", IDcompte_payeur),
            ("parti", parti),
        ]
        if self.mode == "saisie":
            listeDonnees.append(
                ("date_inscription", str(datetime.date.today())))
            self.IDinscription = DB.ReqInsert("inscriptions", listeDonnees)
        else:
            DB.ReqMAJ("inscriptions", listeDonnees, "IDinscription",
                      self.IDinscription)
        DB.Close()

        # Mémorise l'action dans l'historique
        if self.mode == "saisie":
            IDcategorie_historique = 18
            texte_historique = _(
                u"Inscription à l'activité '%s' sur le groupe '%s' avec la tarification '%s'"
            ) % (nomActivite, nomGroupe, nomCategorie)
        else:
            IDcategorie_historique = 20
            texte_historique = _(
                u"Modification de l'inscription à l'activité '%s' sur le groupe '%s' avec la tarification '%s'"
            ) % (nomActivite, nomGroupe, nomCategorie)

        UTILS_Historique.InsertActions([
            {
                "IDindividu": self.IDindividu,
                "IDfamille": IDfamille,
                "IDcategorie": IDcategorie_historique,
                "action": texte_historique,
            },
        ])

        # Saisie de forfaits auto
        if self.mode == "saisie":
            f = DLG_Appliquer_forfait.Forfaits(IDfamille=IDfamille,
                                               listeActivites=[
                                                   IDactivite,
                                               ],
                                               listeIndividus=[
                                                   self.IDindividu,
                                               ],
                                               saisieManuelle=False,
                                               saisieAuto=True)
            f.Applique_forfait(selectionIDcategorie_tarif=IDcategorie_tarif,
                               inscription=True,
                               selectionIDactivite=IDactivite)

        # Fermeture de la fenêtre
        self.EndModal(wx.ID_OK)
Example #9
0
 def OnLeftLink(self, event):
     if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel("familles_factures_email", "modifier") == False : 
         self.UpdateLink()
         return
     self.parent.OnClic()
     self.UpdateLink()
Example #10
0
    def __init__(self, parent):
        wx.Dialog.__init__(self,
                           parent,
                           -1,
                           name="DLG_Enregistrement",
                           style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER
                           | wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX
                           | wx.THICK_FRAME)
        self.parent = parent
        self.derniereValidation = (None, None)

        # Bandeau
        titre = _(u"Enregistrement")
        intro = _(
            u"Vous pouvez saisir ici votre code d'enregistrement personnel afin d'activer votre abonnement Classic ou Premium. Effectuez ce paramétrage sur chacun de vos postes."
        )
        self.SetTitle(titre)
        self.ctrl_bandeau = CTRL_Bandeau.Bandeau(
            self,
            titre=titre,
            texte=intro,
            hauteurHtml=30,
            nomImage="Images/32x32/Cle.png")

        # Saisie code
        self.staticbox_code_staticbox = wx.StaticBox(
            self, -1, _(u"Code d'enregistrement"))
        self.label_identifiant = wx.StaticText(self, -1, _(u"Identifiant :"))
        self.ctrl_identifiant = wx.TextCtrl(self, -1, "")
        self.label_code = wx.StaticText(self, -1, _(u"Code :"))
        self.ctrl_code = masked.TextCtrl(self,
                                         -1,
                                         "",
                                         mask="AAAA-AAAA-AAAA-AAAA-AAAA",
                                         formatcodes="F!")
        self.ctrl_code.SetMinSize((190, -1))
        self.bouton_validite = wx.Button(self, -1,
                                         _(u"Vérifier la validité"))
        self.ctrl_image = wx.StaticBitmap(
            self, -1,
            wx.Bitmap(Chemins.GetStaticPath("Images/16x16/absenti.png"),
                      wx.BITMAP_TYPE_ANY))
        self.label_validite = wx.StaticText(self, -1,
                                            _(u"Veuillez saisir un code."))

        # HTML
        self.ctrl_html = MyHtml(self, texte=TEXTE, hauteur=30)

        # Boutons
        self.bouton_aide = CTRL_Bouton_image.CTRL(
            self, texte=_(u"Aide"), cheminImage="Images/32x32/Aide.png")
        self.bouton_fermer = CTRL_Bouton_image.CTRL(
            self, texte=_(u"Fermer"), cheminImage="Images/32x32/Fermer.png")

        self.__set_properties()
        self.__do_layout()

        self.Bind(wx.EVT_BUTTON, self.OnBoutonValidite, self.bouton_validite)
        self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
        self.Bind(wx.EVT_BUTTON, self.OnBoutonFermer, self.bouton_fermer)
        self.Bind(wx.EVT_CLOSE, self.OnClose)

        # Init contrôles
        identifiant = UTILS_Config.GetParametre("enregistrement_identifiant",
                                                defaut=None)
        code = UTILS_Config.GetParametre("enregistrement_code", defaut=None)
        if identifiant != None and code != None:
            self.ctrl_identifiant.SetValue(identifiant)
            self.ctrl_code.SetValue(code)

        self.VerifieEtat(identifiant, code)

        # Vérifie droits utilisateurs
        if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "parametrage_enregistrement", "modifier",
                afficheMessage=False) == False:
            self.ctrl_identifiant.Enable(False)
            self.ctrl_code.Enable(False)
            self.bouton_validite.Enable(False)
Example #11
0
    def OnBoutonSupprimer(self, event):
        if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "parametrage_utilisateurs_reseau", "supprimer") == False:
            return
        index = self.listCtrl.GetFirstSelected()

        # Vérifie qu'un item a bien été sélectionné
        if index == -1:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous devez d'abord sélectionner un utilisateur à supprimer dans la liste."
                  ), "Information", wx.OK | wx.ICON_INFORMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        nom = self.listCtrl.listeDonnees[index][0]
        hote = self.listCtrl.listeDonnees[index][1]

        # Vérifie que ce n'est pas ROOT
        if nom == "root":
            dlg = wx.MessageDialog(
                self,
                _(u"Vous ne pouvez pas supprimer le compte administrateur"),
                "Information", wx.OK | wx.ICON_INFORMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        # Demande de confirmation
        txtMessage = unicode(
            (_(u"Voulez-vous vraiment supprimer cet utilisateur ? \n\n> %s@%s")
             % (nom, hote)))
        dlgConfirm = wx.MessageDialog(
            self, txtMessage, _(u"Confirmation de suppression"),
            wx.YES_NO | wx.NO_DEFAULT | wx.ICON_QUESTION)
        reponse = dlgConfirm.ShowModal()
        dlgConfirm.Destroy()
        if reponse == wx.ID_NO:
            return

        # Suppression
        DB = GestionDB.DB()
        DB.ExecuterReq("USE mysql;")

        # Suppression de l'autorisation à la base en cours
        for suffixe in LISTE_SUFFIXES:
            req = "SELECT host, db, user FROM db WHERE user='******' and db='%s' and host='%s';" % (
                nom, u"%s_%s" % (self.nomBase, suffixe), hote)
            DB.ExecuterReq(req)
            donnees = DB.ResultatReq()
            if len(donnees) > 0:
                req = u"""REVOKE ALL ON %s.* FROM '%s'@'%s';
                """ % (u"%s_%s" % (self.nomBase, suffixe), nom, hote)
                DB.ExecuterReq(req)

        # Suppression de l'hôte :
        req = "DELETE FROM user WHERE user='******' and host='%s';" % (nom, hote)
        DB.ExecuterReq(req)

        req = u"FLUSH PRIVILEGES;"
        DB.ExecuterReq(req)
        DB.Close()

        # MàJ du ListCtrl
        self.listCtrl.MAJListeCtrl()
Example #12
0
    def Supprimer(self, event):
        if len(self.Selection()) == 0 and len(self.GetTracksCoches()) == 0 :
            dlg = wx.MessageDialog(self, _(u"Vous n'avez sélectionné aucune cotisation à supprimer dans la liste !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        if len(self.GetTracksCoches()) > 0 :
            # Suppression multiple
            listeSelections = self.GetTracksCoches()
            dlg = wx.MessageDialog(self, _(u"Souhaitez-vous vraiment supprimer les %d cotisations cochées ?") % len(listeSelections), _(u"Suppression"), wx.YES_NO|wx.NO_DEFAULT|wx.CANCEL|wx.ICON_INFORMATION)
            reponse = dlg.ShowModal() 
            dlg.Destroy()
            if reponse != wx.ID_YES :
                return
        
        else :
            # Suppression unique
            listeSelections = self.Selection()        
            dlg = wx.MessageDialog(self, _(u"Souhaitez-vous vraiment supprimer la cotisation n°%s ?") % listeSelections[0].numero, _(u"Suppression"), wx.YES_NO|wx.NO_DEFAULT|wx.CANCEL|wx.ICON_INFORMATION)
            reponse = dlg.ShowModal() 
            dlg.Destroy()
            if reponse != wx.ID_YES :
                return

        for track in listeSelections :
            # Vérifie les droits utilisateur
            if track.IDfamille != None and UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel("familles_cotisations", "supprimer") == False : return
            if track.IDindividu != None and UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel("individus_cotisations", "supprimer") == False : return
            # Vérifie les périodes gestion verrouillées
            if self.gestion.Verification("cotisations", track.date_creation_carte) == False: return False

        # Recherche si prestation déjà présente sur facture
        listeID = []
        for track in listeSelections :
            listeID.append(track.IDcotisation) 
        if len(listeID) == 0 : conditionIDcotisation = "()"
        if len(listeID) == 1 : conditionIDcotisation = "(%d)" % listeID[0]
        else : conditionIDcotisation = str(tuple(listeID))
        
        DB = GestionDB.DB()
        req = """SELECT IDcotisation, prestations.date, MIN(IDfacture)
        FROM prestations
        LEFT JOIN cotisations ON cotisations.IDprestation = prestations.IDprestation
        WHERE IDcotisation IN %s
        GROUP BY cotisations.IDcotisation;""" % conditionIDcotisation
        DB.ExecuterReq(req)
        listeFactures = DB.ResultatReq()
        DB.Close() 
        if len(listeFactures) > 0 :
            nbreCotisations = 0
            for IDcotisation, date, IDfacture in listeFactures :
                if self.gestion.Verification("prestations", date) == False: return False

                if IDfacture != None :
                    nbreCotisations += 1

            if nbreCotisations > 0 :
                if nbreCotisations == 1 :
                    message = _(u"Cette cotisation apparaît déjà sur une facture. Il est donc impossible de la supprimer.")
                else :
                    message = _(u"%d de ces cotisations apparaissent déjà sur une ou plusieurs factures. Il est donc impossible d'effectuer la suppression.") % len(listeFactures)
                dlg = wx.MessageDialog(self, message, _(u"Suppression impossible"), wx.OK | wx.ICON_ERROR)
                dlg.ShowModal()
                dlg.Destroy()
                return
        
        # Suppression
        DB = GestionDB.DB()
        for track in listeSelections :
            DB.ReqDEL("cotisations", "IDcotisation", track.IDcotisation)
            if track.IDprestation != None :
                DB.ReqDEL("prestations", "IDprestation", track.IDprestation)
            
            # Mémorise l'action dans l'historique
            UTILS_Historique.InsertActions([{
                "IDindividu" : track.IDindividu,
                "IDfamille" : track.IDfamille,
                "IDcategorie" : 23, 
                "action" : _(u"Suppression de la cotisation ID%d '%s' pour la période du %s au %s") % (track.IDcotisation, track.nomCotisation, UTILS_Dates.DateEngFr(str(track.date_debut)), UTILS_Dates.DateEngFr(str(track.date_fin))),
                },])
                
            # Actualisation de l'affichage
            self.MAJ()
            
        DB.Close() 
        dlg.Destroy()
Example #13
0
 def OnBoutonVisualiserLogo(self, event):
     if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel("parametrage_organisateur", "modifier") == False : return
     self.ctrl_logo.Visualiser()
Example #14
0
    def Supprimer(self, event):
        if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "familles_prestations", "supprimer") == False:
            return
        if len(self.Selection()) == 0 and len(self.GetTracksCoches()) == 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous n'avez sélectionné aucune prestation à supprimer dans la liste !"
                  ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        if len(self.GetTracksCoches()) > 0:
            # Suppression multiple
            listeSelections = self.GetTracksCoches()
            dlg = wx.MessageDialog(
                self,
                _(u"Souhaitez-vous vraiment supprimer les %d prestations cochées ?"
                  ) % len(listeSelections), _(u"Suppression"),
                wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
            reponse = dlg.ShowModal()
            dlg.Destroy()
            if reponse != wx.ID_YES:
                return

        else:
            # Suppression unique
            listeSelections = self.Selection()
            dlg = wx.MessageDialog(
                self,
                _(u"Souhaitez-vous vraiment supprimer la prestation n°%d ?") %
                listeSelections[0].IDprestation, _(u"Suppression"),
                wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
            reponse = dlg.ShowModal()
            dlg.Destroy()
            if reponse != wx.ID_YES:
                return

        nePlusDemanderConfirmation = False
        listeSuppressions = []
        DB = GestionDB.DB()
        for track in listeSelections:

            valide = True

            if self.gestion.Verification("prestations", track.date) == False:
                return False

            # Vérifie si ce n'est pas un forfait non supprimable
            if track.forfait == 2:
                dlg = wx.MessageDialog(
                    self,
                    _(u"La prestation n°%d est un forfait non supprimable !\n\n(Pour le supprimer, vous devez obligatoirement désinscrire l'individu de l'activité)"
                      ) % track.IDprestation, _(u"Suppression impossible"),
                    wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
                valide = False

            # Vérifie qu'aucune facture n'y est rattachée
            if valide == True and track.IDfacture != None:
                dlg = wx.MessageDialog(
                    self,
                    _(u"La prestation n°%d apparaît déjà sur la facture %s.\n\nVous ne pouvez donc pas la supprimer !"
                      ) % (track.IDprestation, track.label_facture),
                    _(u"Suppression impossible"), wx.OK | wx.ICON_INFORMATION)
                dlg.ShowModal()
                dlg.Destroy()
                valide = False

            # Recherche si des consommations y sont attachées
            req = """
            SELECT IDconso, date, consommations.etat, consommations.IDunite, unites.nom, 
            consommations.IDindividu, individus.nom, individus.prenom
            FROM consommations
            LEFT JOIN unites ON unites.IDunite = consommations.IDunite
            LEFT JOIN individus ON individus.IDindividu = consommations.IDindividu
            WHERE IDprestation=%d
            ORDER BY date
            ;""" % track.IDprestation
            DB.ExecuterReq(req)
            listeConsommations = DB.ResultatReq()
            listeIDconso = []
            nbreVerrouillees = 0

            if len(listeConsommations) > 0 and valide == True:
                ##                message = _(u"Attention, la prestation n°%d est rattachée aux %d consommation(s) suivantes :\n\n") % (track.IDprestation, len(listeConsommations))
                ##                lignesConso = []
                ##                for IDconso, date, etat, IDunite, nomUnite, IDindividu, nomIndividu, prenomIndividu in listeConsommations :
                ##                    listeIDconso.append(IDconso)
                ##                    if etat == "present" :
                ##                        nbreVerrouillees += 1
                ##                    dateDD = DateEngEnDateDD(date)
                ##                    dateFr = DateComplete(dateDD)
                ##                    if IDindividu == 0 or IDindividu == None :
                ##                        individu = u""
                ##                    else:
                ##                        individu = _(u"pour %s %s") % (nomIndividu, prenomIndividu)
                ##                    ligneTexte = _(u"   - Le %s : %s %s\n") % (dateFr, nomUnite, individu)
                ##                    #message += ligneTexte
                ##                    lignesConso.append(ligneTexte)
                ##
                ##                maxAffichage = 20
                ##                if len(lignesConso) > maxAffichage :
                ##                    message += "".join(lignesConso[:maxAffichage]) + _(u"   - Et %d autres consommations...\n") % (len(lignesConso) - maxAffichage)
                ##                else :
                ##                    message += "".join(lignesConso)
                ##
                ##                message += _(u"\nSouhaitez-vous supprimer également ces consommations (conseillé) ?\n\n(Si vous répondez non, les consommations seront conservées dans le calendrier mais seront considérées comme gratuites)")

                lignesConso = []
                for IDconso, date, etat, IDunite, nomUnite, IDindividu, nomIndividu, prenomIndividu in listeConsommations:
                    listeIDconso.append(IDconso)
                    if etat == "present":
                        nbreVerrouillees += 1
                    dateDD = DateEngEnDateDD(date)
                    dateFr = DateComplete(dateDD)
                    if IDindividu == 0 or IDindividu == None:
                        individu = u""
                    else:
                        individu = _(u"pour %s %s") % (nomIndividu,
                                                       prenomIndividu)
                    ligneTexte = _(u"   - Le %s : %s %s\n") % (
                        dateFr, nomUnite, individu)
                    #message += ligneTexte
                    lignesConso.append(ligneTexte)

                    if self.gestion.Verification("consommations",
                                                 dateDD) == False:
                        return False

                detail = ""
                maxAffichage = 20
                if len(lignesConso) > maxAffichage:
                    detail += "".join(lignesConso[:maxAffichage]) + _(
                        u"   - Et %d autres consommations...\n") % (
                            len(lignesConso) - maxAffichage)
                else:
                    detail += "".join(lignesConso)

                introduction = _(
                    u"Attention, la prestation n°%d est rattachée aux %d consommation(s) suivantes :"
                ) % (track.IDprestation, len(listeConsommations))
                conclusion = _(
                    u"Souhaitez-vous supprimer également ces consommations (conseillé) ?\n\n(Si vous répondez non, les consommations seront conservées dans le calendrier mais seront considérées comme gratuites)"
                )

                # Demande confirmation pour supprimer les consommations associées
                if nePlusDemanderConfirmation == False:
                    from Dlg import DLG_Messagebox
                    dlg = DLG_Messagebox.Dialog(self,
                                                titre=_(u"Avertissement"),
                                                introduction=introduction,
                                                detail=detail,
                                                conclusion=conclusion,
                                                icone=wx.ICON_EXCLAMATION,
                                                boutons=[
                                                    _(u"Oui"),
                                                    _(u"Oui pour tout"),
                                                    _(u"Non"),
                                                    _(u"Annuler")
                                                ],
                                                defaut=0)
                    reponse = dlg.ShowModal()
                    dlg.Destroy()
                else:
                    reponse = 0

                if reponse == 0 or reponse == 1 or nePlusDemanderConfirmation == True:
                    if nbreVerrouillees > 0:
                        # Annule la procédure d'annulation si des consommations sont déjà pointées sur 'présent' :
                        dlg = wx.MessageDialog(
                            self,
                            _(u"La prestation %d est rattachée à %d consommation(s) déjà pointées.\nIl vous est donc impossible de le(s) supprimer !\n\nProcédure de suppression annulée."
                              ) % (track.IDprestation, nbreVerrouillees),
                            _(u"Suppression impossible"),
                            wx.OK | wx.ICON_EXCLAMATION)
                        dlg.ShowModal()
                        dlg.Destroy()
                        valide = False
                    else:
                        # Suppression des consommations associées
                        for IDconso in listeIDconso:
                            DB.ReqDEL("consommations", "IDconso", IDconso)

                    if reponse == 1:
                        nePlusDemanderConfirmation = True

                if reponse == 2:
                    # Supprime la référence à la prestation des consommations
                    for IDconso in listeIDconso:
                        listeDonnees = [
                            ("IDprestation", None),
                        ]
                        DB.ReqMAJ("consommations", listeDonnees, "IDconso",
                                  IDconso)

                if reponse == 3:
                    return

            # Recherche s'il s'agit d'une prestation de frais de gestion pour un règlement
            if track.reglement_frais != None:
                dlg = wx.MessageDialog(
                    self,
                    _(u"La prestation n°%d est rattachée au règlement n°%d en tant que frais de gestion de règlement.\n\nSouhaitez-vous vraiment supprimer cette prestation ?"
                      ) % (track.IDprestation, track.reglement_frais),
                    _(u"Avertissement"),
                    wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_QUESTION)
                reponse = dlg.ShowModal()
                dlg.Destroy()
                if reponse != wx.ID_YES:
                    valide = False

            # Suppression de la prestation
            if valide == True:
                DB.ReqDEL("prestations", "IDprestation", track.IDprestation)
                DB.ReqDEL("ventilation", "IDprestation", track.IDprestation)
                DB.ReqDEL("deductions", "IDprestation", track.IDprestation)
                listeSuppressions.append(track)

            # MAJ du listeView
            self.MAJ()

        DB.Close()
Example #15
0
    def Validation(self):
        """ Validation des données saisies """
        # Vérifie date de référence
        date_reference = self.ctrl_date_reference.GetDate()
        if self.ctrl_date_reference.FonctionValiderDate() == False or date_reference == None :
            dlg = wx.MessageDialog(self, _(u"La date de référence ne semble pas valide !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            self.ctrl_date_reference.SetFocus()
            return False

        # Vérifier si lot de lettres de rappel
        IDlot = self.ctrl_lot.GetID()
        if IDlot == None :
            dlg = wx.MessageDialog(self, _(u"Vous n'avez pas sélectionné de lot de lettres de rappel à associer. \n\nSouhaitez-vous quand même continuer ?"), _(u"Confirmation"), wx.YES_NO|wx.NO_DEFAULT|wx.CANCEL|wx.ICON_EXCLAMATION)
            resultat = dlg.ShowModal()
            dlg.Destroy()
            if resultat != wx.ID_YES :
                return False
            
        # Date d'émission
        date_emission = self.ctrl_date_emission.GetDate()
        if self.ctrl_date_emission.FonctionValiderDate() == False or date_emission == None :
            dlg = wx.MessageDialog(self, _(u"La date d'émission ne semble pas valide !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            self.ctrl_date_emission.SetFocus()
            return False

        # Vérifier si types de prestations indiquées
        prestations = []
        if self.check_consommations.GetValue() == True : prestations.append("consommation")
        if self.check_cotisations.GetValue() == True : prestations.append("cotisation")
        if self.check_autres.GetValue() == True : prestations.append("autre")
        if len(prestations) == 0 :
            dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement cocher au moins un type de prestation à facturer !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return False
        
        # Familles
        IDcompte_payeur_unique = None
        if self.radio_familles_unique.GetValue() == True :
            IDcompte_payeur_unique = self.ctrl_famille.GetIDcompte_payeur() 
            if IDcompte_payeur_unique == None :
                dlg = wx.MessageDialog(self, _(u"Vous avez sélectionné l'option 'famille unique' mais sans sélectionner de famille dans la liste proposée !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
                return False

        # Vérifie les activités sélectionnées
        listeActivites = self.ctrl_activites.GetActivites() 
        if len(listeActivites) == 0 :
            dlg = wx.MessageDialog(self, _(u"Vous n'avez sélectionné aucune activité !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return False

        # Vérification droits utilisateurs
        for IDactivite in listeActivites :
            if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel("facturation_rappels", "creer", IDactivite=IDactivite, afficheMessage=False) == False : 
                dlg = wx.MessageDialog(self, _(u"Vous n'avez pas l'autorisation de générer des rappels pour l'ensemble des activités sélectionnées !"), _(u"Action non autorisée"), wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
                return False

        # Recherche des exclusions de familles
        listeExclusions = []
        
        if self.radio_familles_prestations.GetValue() == True :
            date_debut = self.ctrl_familles_prestations_min.GetDate() 
            if self.ctrl_familles_prestations_min.FonctionValiderDate() == False or date_debut == None :
                dlg = wx.MessageDialog(self, _(u"La date de début de prestation ne semble pas valide !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
                self.ctrl_familles_prestations_min.SetFocus()
                return False

            date_fin = self.ctrl_familles_prestations_max.GetDate() 
            if self.ctrl_familles_prestations_max.FonctionValiderDate() == False or date_fin == None :
                dlg = wx.MessageDialog(self, _(u"La date de fin de prestation ne semble pas valide !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
                self.ctrl_familles_prestations_max.SetFocus()
                return False

            DB = GestionDB.DB()
            req = """SELECT IDcompte_payeur
            FROM prestations
            WHERE date>='%s' AND date<='%s'
            GROUP BY IDcompte_payeur;""" % (date_debut, date_fin)
            DB.ExecuterReq(req)
            listeDonnees = DB.ResultatReq()
            DB.Close()
            for IDcompte_payeur, in listeDonnees :
                listeExclusions.append(IDcompte_payeur)
            
        if self.radio_familles_lot.GetValue() == True :
            IDlot = self.ctrl_familles_lot.GetID()
            if IDlot == None :
                dlg = wx.MessageDialog(self, _(u"Vous n'avez pas sélectionné de lot de factures dans le filtre familles !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
                return False

            DB = GestionDB.DB()
            req = """SELECT IDcompte_payeur
            FROM factures
            WHERE IDlot=%d
            GROUP BY IDcompte_payeur;""" % IDlot
            DB.ExecuterReq(req)
            listeDonnees = DB.ResultatReq()
            DB.Close()
            for IDcompte_payeur, in listeDonnees :
                listeExclusions.append(IDcompte_payeur)


        # Envoi des données à DLG_Rappels_generation
        self.parent.dictParametres = {
            "date_reference" : date_reference,
            "IDlot" : IDlot,
            "date_edition" : date_emission,
            "prestations" : prestations,
            "IDcompte_payeur" : IDcompte_payeur_unique,
            "listeActivites" : listeActivites,
            "listeExceptionsComptes" : listeExclusions,
            }

        return True
    def MAJ(self):
        """ Importation des données """
        if self.majEffectuee == True:
            return
        self.IDindividu = self.GetGrandParent().IDindividu
        if self.IDindividu == None:
            return

        # MAJ intiale des contrôles
        DB = GestionDB.DB()
        self.ctrl_adresse_auto.MAJ(DB=DB)
        self.ctrl_secteur.MAJ(DB=DB)
        self.ctrl_categorie.MAJ(DB=DB)

        self.listesDiffusionInitiale = []
        self.dictDiffusionInitiale = {}
        self.ctrl_listesdiff.MAJ(DB=DB)

        if self.ctrl_adresse_auto.GetNbreItems() == 0:
            self.ctrl_adresse_auto.Enable(False)
            self.radio_adresse_auto.Enable(False)
            self.radio_adresse_manuelle.SetValue(True)

        # Si pas nouvelle fiche -> Importationd des données
        if self.GetGrandParent().nouvelleFiche == False:

            # Listes de diffusion
            req = """SELECT IDabonnement, IDliste
            FROM abonnements WHERE IDindividu=%d;""" % self.IDindividu
            DB.ExecuterReq(req)
            listeDonnees = DB.ResultatReq()
            listeIDliste = []
            for IDabonnement, IDliste in listeDonnees:
                listeIDliste.append(IDliste)
                self.listesDiffusionInitiale.append(IDliste)
                self.dictDiffusionInitiale[IDliste] = IDabonnement
            self.ctrl_listesdiff.SetIDcoches(listeIDliste)

            # Adresse
            req = """SELECT adresse_auto, rue_resid, cp_resid, ville_resid, IDcategorie_travail, profession, employeur, 
            travail_tel, travail_fax, travail_mail, tel_domicile, tel_mobile, tel_fax, mail, IDsecteur FROM individus WHERE IDindividu=%d;""" % self.IDindividu
            DB.ExecuterReq(req)
            listeDonnees = DB.ResultatReq()
            if len(listeDonnees) > 0:
                individu = listeDonnees[0]

                if individu[0] != None:
                    self.radio_adresse_auto.SetValue(True)
                    self.ctrl_adresse_auto.SetID(individu[0])
                else:
                    self.radio_adresse_manuelle.SetValue(True)
                    try:
                        self.ctrl_rue.SetValue(individu[1])
                    except:
                        pass
                    self.ctrl_ville.SetValueCP(individu[2])
                    self.ctrl_ville.SetValueVille(individu[3])
                    self.ctrl_secteur.SetID(individu[14])

                # Activité professionnelle
                self.ctrl_categorie.SetID(individu[4])
                try:
                    self.ctrl_profession.SetValue(individu[5])
                except:
                    pass
                try:
                    self.ctrl_employeur.SetValue(individu[6])
                except:
                    pass
                self.ctrl_travail_tel.SetNumero(individu[7])
                self.ctrl_travail_fax.SetNumero(individu[8])
                self.ctrl_travail_mail.SetMail(individu[9])

                # Coords
                self.ctrl_tel_domicile.SetNumero(individu[10])
                self.ctrl_tel_mobile.SetNumero(individu[11])
                self.ctrl_tel_fax.SetNumero(individu[12])
                self.ctrl_mail.SetMail(individu[13])

            # Verrouillage utilisateurs
            if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                    "individus_coordonnees", "modifier",
                    afficheMessage=False) == False:
                for ctrl in self.GetChildren():
                    ctrl.Enable(False)

        # MAJ controles
        self.OnRadioAdresse(None)

        DB.Close()
        self.majEffectuee = True
Example #17
0
    def Supprimer(self, event):
        if self.IDcompte_payeur == None and UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "facturation_rappels", "supprimer") == False:
            return

        if len(self.Selection()) == 0 and len(self.GetTracksCoches()) == 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous n'avez sélectionné aucune lettre de rappel à supprimer dans la liste !"
                  ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        if len(self.GetTracksCoches()) > 0:
            # Suppression multiple
            listeSelections = self.GetTracksCoches()
            dlg = wx.MessageDialog(
                self,
                _(u"Souhaitez-vous vraiment supprimer les %d lettres de rappel cochées ?"
                  ) % len(listeSelections), _(u"Suppression"),
                wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
            reponse = dlg.ShowModal()
            dlg.Destroy()
            if reponse != wx.ID_YES:
                return

        else:
            # Suppression unique
            listeSelections = self.Selection()
            dlg = wx.MessageDialog(
                self,
                _(u"Souhaitez-vous vraiment supprimer la lettre de rappel n°%d ?"
                  ) % listeSelections[0].numero, _(u"Suppression"),
                wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
            reponse = dlg.ShowModal()
            dlg.Destroy()
            if reponse != wx.ID_YES:
                return

        # Suppression des lettres de rappel
        listeIDrappels = []
        for track in listeSelections:
            listeIDrappels.append(track.IDrappel)

        dlgAttente = PBI.PyBusyInfo(
            _(u"Suppression des lettres de rappel en cours..."),
            parent=None,
            title=_(u"Veuillez patienter..."),
            icon=wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Logo.png"),
                           wx.BITMAP_TYPE_ANY))
        wx.Yield()
        DB = GestionDB.DB()
        for IDrappel in listeIDrappels:
            DB.ReqDEL("rappels", "IDrappel", IDrappel)
        DB.Close()
        del dlgAttente

        # MAJ du listeView
        self.MAJ()

        # Confirmation de suppression
        dlg = wx.MessageDialog(
            self,
            _(u"%d lettres(s) de rappel supprimée(s) avec succès.") %
            len(listeSelections), _(u"Suppression"),
            wx.OK | wx.ICON_INFORMATION)
        dlg.ShowModal()
        dlg.Destroy()
Example #18
0
    def __init__(self, parent):
        wx.Dialog.__init__(self,
                           parent,
                           -1,
                           style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER
                           | wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX)
        self.parent = parent

        # Init moteur vocal
        self.vocal = UTILS_Vocal.Vocal()

        # Bandeau
        intro = _(
            u"Vous pouvez paramétrer et tester ici la synthèse vocale utilisée par Noethys. Attention, si ce n'est pas déjà fait, téléchargez dès à présent la voix française ci-dessous !"
        )
        titre = _(u"Synthèse vocale")
        self.SetTitle(titre)
        self.ctrl_bandeau = CTRL_Bandeau.Bandeau(
            self,
            titre=titre,
            texte=intro,
            hauteurHtml=30,
            nomImage="Images/32x32/Vocal.png")

        # Paramètres
        self.box_parametres_staticbox = wx.StaticBox(
            self, -1, _(u"Paramètres de la voix"))
        self.label_voix = wx.StaticText(self, -1, _(u"Voix actuelle :"))
        self.ctrl_voix = CTRL_Voix(self, vocal=self.vocal)

        # Avertissement
        self.ctrl_avertissement = CTRL_Avertissement(self)
        self.MAJAvertissement()

        # Corrections
        self.box_corrections_staticbox = wx.StaticBox(
            self, -1, _(u"Corrections phoniques"))
        self.ctrl_corrections = OL_Corrections_phoniques.ListView(
            self,
            id=-1,
            style=wx.LC_REPORT | wx.SUNKEN_BORDER | wx.LC_SINGLE_SEL
            | wx.LC_HRULES | wx.LC_VRULES)
        self.ctrl_corrections.MAJ()
        self.bouton_ajouter = wx.BitmapButton(
            self, -1,
            wx.Bitmap(Chemins.GetStaticPath(u"Images/16x16/Ajouter.png"),
                      wx.BITMAP_TYPE_ANY))
        self.bouton_modifier = wx.BitmapButton(
            self, -1,
            wx.Bitmap(Chemins.GetStaticPath(u"Images/16x16/Modifier.png"),
                      wx.BITMAP_TYPE_ANY))
        self.bouton_supprimer = wx.BitmapButton(
            self, -1,
            wx.Bitmap(Chemins.GetStaticPath(u"Images/16x16/Supprimer.png"),
                      wx.BITMAP_TYPE_ANY))

        # Test
        self.box_test_staticbox = wx.StaticBox(self, -1, _(u"Test"))
        self.ctrl_test = wx.TextCtrl(self, -1, u"")

        # Boutons
        self.bouton_test = wx.BitmapButton(
            self, -1,
            wx.Bitmap(Chemins.GetStaticPath(u"Images/16x16/Vocal.png"),
                      wx.BITMAP_TYPE_ANY))
        self.bouton_aide = CTRL_Bouton_image.CTRL(
            self, texte=_(u"Aide"), cheminImage="Images/32x32/Aide.png")
        self.bouton_fermer = CTRL_Bouton_image.CTRL(
            self,
            id=wx.ID_CANCEL,
            texte=_(u"Fermer"),
            cheminImage="Images/32x32/Fermer.png")

        self.__set_properties()
        self.__do_layout()

        self.Bind(wx.EVT_CHOICE, self.OnChoixVoix, self.ctrl_voix)
        self.Bind(wx.EVT_BUTTON, self.OnAjouterCorrection, self.bouton_ajouter)
        self.Bind(wx.EVT_BUTTON, self.OnModifierCorrection,
                  self.bouton_modifier)
        self.Bind(wx.EVT_BUTTON, self.OnSupprimerCorrection,
                  self.bouton_supprimer)
        self.Bind(wx.EVT_BUTTON, self.OnBoutonTest, self.bouton_test)
        self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)

        if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "parametrage_vocal", "modifier",
                afficheMessage=False) == False:
            self.ctrl_voix.Enable(False)
            self.bouton_ajouter.Enable(False)
            self.bouton_modifier.Enable(False)
            self.bouton_supprimer.Enable(False)
Example #19
0
    def OuvrirFicheFamille(self,
                           track=None,
                           ouvrirGrille=False,
                           ouvrirFicheInd=False):
        if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "familles_fiche", "consulter") == False:
            return

        IDindividu = track.IDindividu

        rattachements, dictTitulaires, txtTitulaires = track.GetRattachements()
        if rattachements != None:
            rattachements.sort()

        # Rattaché à aucune famille
        if rattachements == None:
            dlg = wx.MessageDialog(
                self,
                _(u"Cet individu n'est rattaché à aucune famille.\n\nSouhaitez-vous ouvrir sa fiche individuelle ?"
                  ), _(u"Confirmation"),
                wx.YES_NO | wx.YES_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
            reponse = dlg.ShowModal()
            dlg.Destroy()
            if reponse != wx.ID_YES:
                return False
            else:
                # Ouverture de la fiche individuelle
                from Dlg import DLG_Individu
                dlg = DLG_Individu.Dialog(None, IDindividu=IDindividu)
                if dlg.ShowModal() == wx.ID_OK:
                    pass
                dlg.Destroy()
                self.MAJ()
                return

        # Rattachée à une seule famille
        elif len(rattachements) == 1:
            IDcategorie, IDfamille, titulaire = rattachements[0]
        # Rattachée à plusieurs familles
        else:
            listeNoms = []
            for IDcategorie, IDfamille, titulaire in rattachements:
                nomTitulaires = dictTitulaires[IDfamille]
                if IDcategorie == 1:
                    nomCategorie = _(u"représentant")
                    if titulaire == 1:
                        nomCategorie += _(u" titulaire")
                if IDcategorie == 2: nomCategorie = _(u"enfant")
                if IDcategorie == 3: nomCategorie = _(u"contact")
                listeNoms.append(
                    _(u"%s (en tant que %s)") % (nomTitulaires, nomCategorie))
            dlg = wx.SingleChoiceDialog(
                self,
                _(u"Cet individu est rattaché à %d familles.\nLa fiche de quelle famille souhaitez-vous ouvrir ?"
                  ) % len(listeNoms), _(u"Rattachements multiples"), listeNoms,
                wx.CHOICEDLG_STYLE)
            IDfamilleSelection = None
            if dlg.ShowModal() == wx.ID_OK:
                indexSelection = dlg.GetSelection()
                IDcategorie, IDfamille, titulaire = rattachements[
                    indexSelection]
                dlg.Destroy()
            else:
                dlg.Destroy()
                return

        # Ouverture de la fiche famille
        if IDfamille != None and IDfamille != -1:
            from Dlg import DLG_Famille
            if ouvrirGrille == True or ouvrirFicheInd == True:
                AfficherMessagesOuverture = False
            else:
                AfficherMessagesOuverture = True
            dlg = DLG_Famille.Dialog(
                self,
                IDfamille=IDfamille,
                AfficherMessagesOuverture=AfficherMessagesOuverture)
            # Ouverture grille de l'individ
            if ouvrirGrille == True:
                dlg.OuvrirGrilleIndividu(IDindividu)
            # Ouverture fiche de l'individu
            if ouvrirFicheInd == True:
                dlg.OuvrirFicheIndividu(IDindividu)
            if dlg.ShowModal() == wx.ID_OK:
                self.MAJ(IDindividu)
            try:
                dlg.Destroy()
            except:
                pass
            # MAJ du remplissage
            try:
                if self.GetGrandParent().GetName() == "general":
                    self.GetGrandParent().MAJ()
                else:
                    self.MAJ()
            except:
                pass
            # Mémorisation pour l'historique de la barre de recherche rapide
            try:
                if IDindividu not in self.historique:
                    self.historique.append(IDindividu)
                    if len(self.historique) > 30:
                        self.historique.pop(0)
            except:
                pass
Example #20
0
    def Exporter(self, event):
        """ Exporter """
        if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "parametrage_activites", "consulter") == False:
            return
        # Demande les activités à exporter
        listeActivites = []
        listeLabels = []
        for track in self.GetObjects():
            label = u"%s (%s)" % (track.nom, track.labelPeriode)
            listeLabels.append(label)
            listeActivites.append((track.IDactivite, track.nom))

        dlg = wx.MultiChoiceDialog(
            None, _(u"Sélectionnez les activités à exporter :"),
            _(u"Exportation"), listeLabels)
        dlg.SetSize((550, 500))
        if dlg.ShowModal() == wx.ID_OK:
            selections = dlg.GetSelections()
        else:
            selections = []
        dlg.Destroy()
        if len(selections) == 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous n'avez sélectionné aucune activité à exporter !\n\nExportation annulée."
                  ), _(u"Exportation"), wx.OK | wx.ICON_INFORMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        listeSelection = []
        for index in selections:
            listeSelection.append(listeActivites[index])

        # Demande le chemin pour la sauvegarde du fichier
        standardPath = wx.StandardPaths.Get()
        dlg = wx.FileDialog(self,
                            message=_(u"Enregistrer le fichier sous..."),
                            defaultDir=standardPath.GetDocumentsDir(),
                            defaultFile="activites.nxa",
                            wildcard=_(u"Activité Noethys (*.nxa)|*.nxa"),
                            style=wx.SAVE)

        if dlg.ShowModal() == wx.ID_OK:
            path = dlg.GetPath()
        else:
            path = None
        dlg.Destroy()
        if path == None:
            return

        # Le fichier de destination existe déjà :
        if os.path.isfile(path) == True:
            dlg = wx.MessageDialog(
                None,
                _(u"Un fichier portant ce nom existe déjà. \n\nVoulez-vous le remplacer ?"
                  ), "Attention !",
                wx.YES_NO | wx.NO_DEFAULT | wx.ICON_EXCLAMATION)
            if dlg.ShowModal() == wx.ID_NO:
                return False
                dlg.Destroy()
            else:
                dlg.Destroy()

        # Exportation
        exportation = Exporter(categorie="activite")
        for IDactivite, nom in listeSelection:
            exportation.Ajouter(IDactivite, nom)
        exportation.Enregistrer(fichier=path)

        # Confirmation
        dlg = wx.MessageDialog(
            self,
            _(u"%d activité(s) ont été exportées avec succès.") %
            len(listeSelection), _(u"Exportation"),
            wx.OK | wx.ICON_INFORMATION)
        dlg.ShowModal()
        dlg.Destroy()
Example #21
0
    def Supprimer(self, event):
        if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "parametrage_ecoles", "supprimer") == False:
            return
        if len(self.Selection()) == 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous n'avez sélectionné aucune école dans la liste"),
                _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return
        IDecole = self.Selection()[0].IDecole

        # Vérifie que cette école n'a pas déjà été attribué à une classe
        DB = GestionDB.DB()
        req = """SELECT COUNT(IDclasse)
        FROM classes 
        WHERE IDecole=%d
        ;""" % IDecole
        DB.ExecuterReq(req)
        nbreClasses = int(DB.ResultatReq()[0][0])
        DB.Close()
        if nbreClasses > 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Cette école a déjà été rattachée à %d classes.\nVous ne pouvez donc la supprimer."
                  ) % nbreClasses, _(u"Avertissement"),
                wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        # Vérifie que cette école n'a pas déjà été attribué à une scolarité
        DB = GestionDB.DB()
        req = """SELECT COUNT(IDindividu)
        FROM scolarite 
        WHERE IDecole=%d
        ;""" % IDecole
        DB.ExecuterReq(req)
        nbreIndividus = int(DB.ResultatReq()[0][0])
        DB.Close()
        if nbreIndividus > 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Cette école a déjà été attribuée à %d individus.\nVous ne pouvez donc la supprimer."
                  ) % nbreIndividus, _(u"Avertissement"),
                wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        # Confirmation de suppression
        dlg = wx.MessageDialog(
            self, _(u"Souhaitez-vous vraiment supprimer cette école ?"),
            _(u"Suppression"),
            wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
        if dlg.ShowModal() == wx.ID_YES:
            DB = GestionDB.DB()
            DB.ReqDEL("ecoles", "IDecole", IDecole)
            DB.Close()
            self.MAJ()
        dlg.Destroy()
Example #22
0
    def Supprimer(self, event):
        if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "parametrage_comptes_bancaires", "supprimer") == False:
            return
        if len(self.Selection()) == 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous n'avez sélectionné aucun compte à supprimer dans la liste !"
                  ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return
        IDcompte = self.Selection()[0].IDcompte

        # Vérifie que ce compte n'a pas déjà été attribué à un règlement
        DB = GestionDB.DB()
        req = """SELECT COUNT(IDreglement)
        FROM reglements 
        WHERE IDcompte=%d
        ;""" % IDcompte
        DB.ExecuterReq(req)
        nbre = int(DB.ResultatReq()[0][0])
        DB.Close()
        if nbre > 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Ce compte a déjà été attribué à %d règlement(s).\n\nVous ne pouvez donc pas le supprimer !"
                  ) % nbre, _(u"Suppression impossible"),
                wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        # Vérifie que ce compte n'a pas déjà été attribué à un dépôt
        DB = GestionDB.DB()
        req = """SELECT COUNT(IDdepot)
        FROM depots 
        WHERE IDcompte=%d
        ;""" % IDcompte
        DB.ExecuterReq(req)
        nbre = int(DB.ResultatReq()[0][0])
        DB.Close()
        if nbre > 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Ce compte a déjà été attribué à %d dépôt(s) de règlements.\n\nVous ne pouvez donc pas le supprimer !"
                  ) % nbre, _(u"Suppression impossible"),
                wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        # Vérifie que ce compte n'a pas déjà été attribué à une opération comptable
        DB = GestionDB.DB()
        req = """SELECT COUNT(IDoperation)
        FROM compta_operations 
        WHERE IDcompte_bancaire=%d
        ;""" % IDcompte
        DB.ExecuterReq(req)
        nbre = int(DB.ResultatReq()[0][0])
        DB.Close()
        if nbre > 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Ce compte a déjà été attribué à %d opérations comptables.\n\nVous ne pouvez donc pas le supprimer !"
                  ) % nbre, _(u"Suppression impossible"),
                wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        # Vérifie que ce compte n'a pas déjà été attribué à un relevé de compte
        DB = GestionDB.DB()
        req = """SELECT COUNT(IDreleve)
        FROM compta_releves 
        WHERE IDcompte_bancaire=%d
        ;""" % IDcompte
        DB.ExecuterReq(req)
        nbre = int(DB.ResultatReq()[0][0])
        DB.Close()
        if nbre > 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Ce compte a déjà été attribué à %d relevés de compte.\n\nVous ne pouvez donc pas le supprimer !"
                  ) % nbre, _(u"Suppression impossible"),
                wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        # Suppression
        dlg = wx.MessageDialog(
            self, _(u"Souhaitez-vous vraiment supprimer ce compte bancaire ?"),
            _(u"Suppression"),
            wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
        if dlg.ShowModal() == wx.ID_YES:
            DB = GestionDB.DB()
            # Suppression de l'identité
            DB.ReqDEL("comptes_bancaires", "IDcompte", IDcompte)
            # Attribue le Défaut à un autre compte
            if self.Selection()[0].defaut == 1:
                req = """SELECT IDcompte, defaut
                FROM comptes_bancaires
                ORDER BY nom
                ; """
                DB.ExecuterReq(req)
                listeDonnees = DB.ResultatReq()
                if len(listeDonnees) > 0:
                    DB.ReqMAJ("comptes_bancaires", [
                        ("defaut", 1),
                    ], "IDcompte", listeDonnees[0][0])
            DB.Close()
            self.MAJ()
        dlg.Destroy()
 def Ajouter(self, event):
     if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel("parametrage_releves_bancaires", "creer") == False : return
     dlg = DLG_Saisie_releve_compta.Dialog(self, IDreleve=None, IDcompte_bancaire=self.IDcompte_bancaire)
     if dlg.ShowModal() == wx.ID_OK:
         self.MAJ(dlg.GetIDreleve() )
     dlg.Destroy()
Example #24
0
 def IsLectureAutorisee(self):
     if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel("familles_locations", "consulter", afficheMessage=False) == False :
         return False
     return True
Example #25
0
    def MAJ(self):
        """ MAJ integrale du controle avec MAJ des donnees """
        if self.majEffectuee == False:
            self.ctrl_parametres.MAJ()
            DB = GestionDB.DB()
            req = """SELECT internet_actif, internet_identifiant, internet_mdp, titulaire_helios, code_comptable, idtiers_helios, natidtiers_helios, reftiers_helios, cattiers_helios, natjur_helios, autre_adresse_facturation
            FROM familles
            WHERE IDfamille=%d;""" % self.IDfamille
            DB.ExecuterReq(req)
            listeDonnees = DB.ResultatReq()
            DB.Close()
            if len(listeDonnees) > 0:
                internet_actif, internet_identifiant, internet_mdp, titulaire_helios, code_comptable, idtiers_helios, natidtiers_helios, reftiers_helios, cattiers_helios, natjur_helios, autre_adresse_facturation = listeDonnees[
                    0]

                # Compte internet
                self.ctrl_compte_internet.SetDonnees({
                    "internet_actif":
                    internet_actif,
                    "internet_identifiant":
                    internet_identifiant,
                    "internet_mdp":
                    internet_mdp
                })

                # Hélios
                self.ctrl_parametres.SetPropertyValue("titulaire_helios",
                                                      titulaire_helios)
                if idtiers_helios != None:
                    self.ctrl_parametres.SetPropertyValue(
                        "idtiers_helios", idtiers_helios)
                if natidtiers_helios != None:
                    self.ctrl_parametres.SetPropertyValue(
                        "natidtiers_helios", natidtiers_helios)
                if reftiers_helios != None:
                    self.ctrl_parametres.SetPropertyValue(
                        "reftiers_helios", reftiers_helios)
                if cattiers_helios != None:
                    self.ctrl_parametres.SetPropertyValue(
                        "cattiers_helios", cattiers_helios)
                if natjur_helios != None:
                    self.ctrl_parametres.SetPropertyValue(
                        "natjur_helios", natjur_helios)

                # Autre adresse de facturation
                self.ctrl_parametres.SetAdresseFacturation(
                    autre_adresse_facturation)

                # Code comptable
                self.ctrl_parametres.SetPropertyValue("code_comptable",
                                                      code_comptable)
            self.MAJaffichage()

        else:
            self.ctrl_parametres.MAJ()

        # Droits utilisateurs
        if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "familles_compte_internet", "modifier",
                afficheMessage=False) == False:
            self.bouton_modifier.Enable(False)

        self.majEffectuee = True
Example #26
0
 def OnBoutonModifier(self, event):
     if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel("parametrage_utilisateurs_reseau", "modifier") == False : return
     dlg = wx.MessageDialog(self, _(u"Actuellement, il n'est pas encore possible de modifier un utilisateur. \nVous devez donc supprimer l'utilisateur et le re-créer."), "Information", wx.OK | wx.ICON_INFORMATION)
     dlg.ShowModal()
     dlg.Destroy()      
Example #27
0
    def Supprimer(self, event):
        if len(self.Selection()) == 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous n'avez sélectionné aucun utilisateur à supprimer dans la liste !"
                  ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return
        if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "parametrage_utilisateurs", "supprimer") == False:
            return
        IDutilisateur = self.Selection()[0].IDutilisateur
        profil = self.Selection()[0].profil
        # Vérifie que cet utilisateur n'est pas déjà attribué à d'autres tables de données

        # Table Consommations
        DB = GestionDB.DB()
        req = """SELECT COUNT(IDconso)
        FROM consommations 
        WHERE IDutilisateur=%d
        ;""" % IDutilisateur
        DB.ExecuterReq(req)
        nbreConso = int(DB.ResultatReq()[0][0])
        DB.Close()
        if nbreConso > 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Cet utilisateur a déjà été attribué à %d consommation(s).\n\nVous ne pouvez donc pas le supprimer !"
                  ) % nbreConso, _(u"Suppression impossible"),
                wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        # Table Règlements
        DB = GestionDB.DB()
        req = """SELECT COUNT(IDreglement)
        FROM reglements 
        WHERE IDutilisateur=%d
        ;""" % IDutilisateur
        DB.ExecuterReq(req)
        nbreReglements = int(DB.ResultatReq()[0][0])
        DB.Close()
        if nbreReglements > 0:
            dlg = wx.MessageDialog(
                self,
                _(u"Cet utilisateur a déjà été attribué à %d règlement(s).\n\nVous ne pouvez donc pas le supprimer !"
                  ) % nbreReglements, _(u"Suppression impossible"),
                wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return

        # Vérifie qu'il reste au moins un administrateur
        if profil == "administrateur":
            nbreAdmin = 0
            for track in self.donnees:
                if track.profil == "administrateur" and track.IDutilisateur != IDutilisateur:
                    nbreAdmin += 1
            if nbreAdmin == 0:
                dlg = wx.MessageDialog(
                    self,
                    _(u"Vous ne pouvez pas supprimer le seul administrateur !"
                      ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
                return

        # Suppression
        dlg = wx.MessageDialog(
            self, _(u"Souhaitez-vous vraiment supprimer cet utilisateur ?"),
            _(u"Suppression"),
            wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
        if dlg.ShowModal() == wx.ID_YES:
            DB = GestionDB.DB()
            DB.ReqDEL("utilisateurs", "IDutilisateur", IDutilisateur)
            DB.ReqDEL("droits", "IDutilisateur", IDutilisateur)
            DB.Close()
            self.MAJ()
        dlg.Destroy()
Example #28
0
    def Validation(self):
        IDactivite = self.GetIDactivite()
        if IDactivite == None:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous devez obligatoirement sélectionner une activité !"),
                _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return False

        IDgroupe = self.ctrl_groupes.GetID()
        if IDgroupe == None:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous devez obligatoirement sélectionner un groupe !"),
                _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return False

        IDcategorie_tarif = self.ctrl_categories.GetID()
        if IDcategorie_tarif == None:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous devez obligatoirement sélectionner une catégorie de tarifs !"
                  ), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return False

        IDfamille = self.GetGrandParent().ctrl_famille.GetID()
        if IDfamille == None:
            dlg = wx.MessageDialog(
                self,
                _(u"Vous devez obligatoirement sélectionner une famille !"),
                _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
            dlg.ShowModal()
            dlg.Destroy()
            return False

        nomActivite = self.ctrl_activite.GetNomActivite()

        statut = self.parent.parent.ctrl_statut.GetID()

        DB = GestionDB.DB()

        self.action_consommation = None

        # Date départ
        if self.ctrl_check_depart.IsChecked():
            if self.ctrl_date_depart.GetDate(
            ) == None or self.ctrl_date_depart.Validation() == False:
                dlg = wx.MessageDialog(
                    self, _(u"Vous devez saisir une date de départ valide !"),
                    _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
                DB.Close()
                return False

            if self.date_inscription != None and self.ctrl_date_depart.GetDate(
            ) < self.date_inscription:
                DB.Close()
                dlg = wx.MessageDialog(
                    self,
                    _(u"La date de départ doit être supérieure ou égale à la date d'inscription !"
                      ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
                return False

            date_desinscription = str(self.ctrl_date_depart.GetDate())

            # Vérifie que il n'existe pas des conso après cette date
            if self.IDinscription != None:
                req = """SELECT IDconso, date
                FROM consommations
                WHERE IDinscription=%d AND date>'%s';""" % (
                    self.IDinscription, date_desinscription)
                DB.ExecuterReq(req)
                listeConso = DB.ResultatReq()
                titre = _(u"Consommations existantes")
                introduction = _(
                    u"Il existe %d consommations enregistrées après la date de départ. "
                ) % len(listeConso)
                introduction += _(
                    u"Si vous les conservez elles seront considérées comme gratuites. "
                )
                introduction += _(
                    u"Voulez-vous les supprimer définitivement.")
                conclusion = _(u"Oui pour les supprimer.\n")
                conclusion += _(u"Non pour les conserver.")
                if len(listeConso) > 0:
                    dlg = DLG_Messagebox.Dialog(
                        self,
                        titre=titre,
                        introduction=introduction,
                        conclusion=conclusion,
                        icone=wx.ICON_QUESTION,
                        boutons=[_(u"Oui"),
                                 _(u"Non"),
                                 _(u"Annuler")])
                    reponse = dlg.ShowModal()
                    dlg.Destroy()
                    if reponse == 0:
                        # Il faudra supprimer les consommations existantes
                        self.action_consommation = self.SupprimerConsommations
                    elif reponse == 1:
                        # Il faudra garder les consommations existantes
                        self.action_consommation = self.PreserverConsommations
                    else:
                        DB.Close()
                        return False

        # Verrouillage utilisateurs
        if self.parent.mode == "saisie":
            action = "creer"
        else:
            action = "modifier"
        if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "individus_inscriptions", action,
                IDactivite=IDactivite) == False:
            DB.Close()
            return False

        # Vérifie que l'individu n'est pas déjà inscrit à cette activite
        if self.parent.mode == "saisie":
            req = """SELECT IDinscription, IDindividu, IDfamille
            FROM inscriptions
            WHERE IDindividu=%d AND IDfamille=%d AND IDactivite=%d;""" % (
                self.parent.IDindividu, IDfamille, IDactivite)
            DB.ExecuterReq(req)
            listeDonnees = DB.ResultatReq()
            if len(listeDonnees) > 0:
                DB.Close()
                dlg = wx.MessageDialog(
                    self,
                    _(u"Cet individu est déjà inscrit à l'activité '%s' !")
                    % nomActivite, _(u"Erreur de saisie"),
                    wx.OK | wx.ICON_ERROR)
                dlg.ShowModal()
                dlg.Destroy()
                return False

        # Vérification du nombre d'inscrits max de l'activité
        if (statut == "ok"
                and self.ancien_statut != "ok") or (IDgroupe != self.IDgroupe):
            reponse = None

            if self.dictActivite["nbre_places_disponibles"] != None:
                if self.dictActivite["nbre_places_disponibles"] <= 0:
                    intro = _(
                        u"Le nombre maximal d'inscrits autorisé pour cette activité (%d places max) a été atteint !\n\nQue souhaitez-vous faire ?"
                    ) % self.dictActivite["nbre_inscrits_max"]
                    dlg = DLG_Messagebox.Dialog(
                        self,
                        titre=_(u"Nbre d'inscrit maximal atteint"),
                        introduction=intro,
                        detail=None,
                        icone=wx.ICON_EXCLAMATION,
                        boutons=[
                            _(u"Valider quand même"),
                            _(u"Mettre en attente"),
                            _(u"Refuser"),
                            _(u"Annuler")
                        ],
                        defaut=1)
                    reponse = dlg.ShowModal()
                    dlg.Destroy()

            # Vérification du nombre d'inscrits max du groupe
            if reponse == None:
                for dictGroupe in self.dictActivite["groupes"]:
                    if dictGroupe["IDgroupe"] == IDgroupe and dictGroupe[
                            "nbre_places_disponibles"] != None:
                        if dictGroupe["nbre_places_disponibles"] <= 0:
                            intro = _(
                                u"Le nombre maximal d'inscrits autorisé sur ce groupe (%d places max) a été atteint !\n\nQue souhaitez-vous faire ?"
                            ) % dictGroupe["nbre_inscrits_max"]
                            dlg = DLG_Messagebox.Dialog(
                                self,
                                titre=_(u"Nbre d'inscrit maximal atteint"),
                                introduction=intro,
                                detail=None,
                                icone=wx.ICON_EXCLAMATION,
                                boutons=[
                                    _(u"Valider quand même"),
                                    _(u"Mettre en attente"),
                                    _(u"Refuser"),
                                    _(u"Annuler")
                                ],
                                defaut=1)
                            reponse = dlg.ShowModal()
                            dlg.Destroy()

            # Applique un statut à l'inscription
            if reponse != None:
                if reponse == 0:
                    self.parent.parent.ctrl_statut.SetID("ok")
                elif reponse == 1:
                    self.parent.parent.ctrl_statut.SetID("attente")
                elif reponse == 2:
                    self.parent.parent.ctrl_statut.SetID("refus")
                else:
                    DB.Close()
                    return False

        # Si changement de statut : Vérifie si l'individu n'a pas déjà des prestations
        if self.IDinscription != None and statut != "ok" and self.ancien_statut == "ok":
            req = """SELECT IDprestation, prestations.date, prestations.forfait
            FROM prestations
            WHERE IDactivite=%d AND IDindividu=%d
            ;""" % (IDactivite, self.parent.parent.IDindividu)
            DB.ExecuterReq(req)
            listePrestations = DB.ResultatReq()
            if len(listePrestations) > 0:
                DB.Close()
                dlg = wx.MessageDialog(
                    self,
                    _(u"Vous ne pouvez pas modifier le statut de cette inscription car des prestations y ont déjà été associées !"
                      ), _(u"Erreur"), wx.OK | wx.ICON_ERROR)
                dlg.ShowModal()
                dlg.Destroy()
                return False

        DB.Close()
        return True
    def OnBoutonOk(self, event):
        if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "parametrage_organisateur", "modifier") == False:
            return

        nom = self.ctrl_nom.GetValue()
        rue = self.ctrl_rue.GetValue()
        cp = self.ctrl_adresse.GetValueCP()
        ville = self.ctrl_adresse.GetValueVille()
        tel = self.ctrl_tel.GetNumero()
        fax = self.ctrl_fax.GetNumero()
        mail = self.ctrl_mail.GetMail()
        site = self.ctrl_site.GetValue()
        num_agrement = self.ctrl_agrement.GetValue()
        num_siret = self.ctrl_siret.GetValue()
        code_ape = self.ctrl_ape.GetValue()
        gps = self.GetGPSOrganisateur(cp, ville)

        # Sauvegarde
        DB = GestionDB.DB()
        listeDonnees = [
            ("nom", nom),
            ("rue", rue),
            ("cp", cp),
            ("ville", ville),
            ("tel", tel),
            ("fax", fax),
            ("mail", mail),
            ("site", site),
            ("num_agrement", num_agrement),
            ("num_siret", num_siret),
            ("code_ape", code_ape),
            ("gps", gps),
        ]

        if self.ctrl_logo.estModifie == True:
            logo_update = datetime.datetime.now()
            listeDonnees.append(("logo_update", logo_update))

        req = """SELECT nom FROM organisateur WHERE IDorganisateur=1;"""
        DB.ExecuterReq(req)
        test = DB.ResultatReq()
        if len(test) == 0:
            IDorganisateur = DB.ReqInsert("organisateur", listeDonnees)
        else:
            DB.ReqMAJ("organisateur", listeDonnees, "IDorganisateur", 1)

        # Sauvegarde du logo
        if self.ctrl_logo.estModifie == True:
            bmp = self.ctrl_logo.GetBuffer()
            if bmp != None:
                DB.MAJimage(table="organisateur",
                            key="IDorganisateur",
                            IDkey=1,
                            blobImage=bmp,
                            nomChampBlob="logo")
            else:
                DB.ReqMAJ("organisateur", [
                    ("logo", None),
                ], "IDorganisateur", 1)
        DB.Close()

        # Fermeture de la fenêtre
        self.EndModal(wx.ID_OK)
Example #30
0
    def Ajouter(self, event):
        if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
                "individus_scolarite", "creer") == False:
            return

        # Recherches des dernières dates saisies
        DB = GestionDB.DB()
        req = """SELECT date_debut, date_fin
        FROM scolarite 
        ORDER BY IDscolarite DESC LIMIT 1;"""
        DB.ExecuterReq(req)
        listeDonnees = DB.ResultatReq()
        DB.Close()
        if len(listeDonnees) > 0:
            date_debut = DateEngEnDateDD(listeDonnees[0][0])
            date_fin = DateEngEnDateDD(listeDonnees[0][1])
        else:
            date_debut = None
            date_fin = None

        # Ouverture de la DLG de saisie
        from Dlg import DLG_Saisie_scolarite
        dlg = DLG_Saisie_scolarite.Dialog(self,
                                          IDscolarite=None,
                                          donneesScolarite=self.donnees)
        dlg.SetDateDebut(date_debut)
        dlg.SetDateFin(date_fin)
        if dlg.ShowModal() == wx.ID_OK:
            date_debut = dlg.GetDateDebut()
            date_fin = dlg.GetDateFin()
            IDecole = dlg.GetEcole()
            IDclasse = dlg.GetClasse()
            IDniveau = dlg.GetNiveau()
            nomEcole = dlg.GetNomEcole()
            nomClasse = dlg.GetNomClasse()
            nomNiveau = dlg.GetNomNiveau()

            # Sauvegarde
            DB = GestionDB.DB()
            listeDonnees = [
                ("IDindividu", self.IDindividu),
                ("date_debut", date_debut),
                ("date_fin", date_fin),
                ("IDecole", IDecole),
                ("IDclasse", IDclasse),
                ("IDniveau", IDniveau),
            ]
            IDscolarite = DB.ReqInsert("scolarite", listeDonnees)
            DB.Close()

            # Mémorise l'action dans l'historique
            UTILS_Historique.InsertActions([
                {
                    "IDindividu":
                    self.IDindividu,
                    "IDfamille":
                    None,
                    "IDcategorie":
                    30,
                    "action":
                    _(u"Inscription scolaire du %s au %s. Ecole : '%s'. Classe : '%s'. Niveau : '%s'"
                      ) % (DateEngFr(str(date_debut)), DateEngFr(
                          str(date_fin)), nomEcole, nomClasse, nomNiveau)
                },
            ])

            # Actualise l'affichage
            self.MAJ(IDscolarite)
        dlg.Destroy()