def Importation(self): DB = GestionDB.DB() # Récupération des unités de réservations req = """SELECT IDunite, IDactivite, nom, unites_principales, unites_secondaires, ordre FROM portail_unites;""" DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() self.dictUnites = {} for IDunite, IDactivite, nom, unites_principales, unites_secondaires, ordre in listeDonnees : unites_principales = UTILS_Texte.ConvertStrToListe(unites_principales) unites_secondaires = UTILS_Texte.ConvertStrToListe(unites_secondaires) self.dictUnites[IDunite] = { "IDactivite" : IDactivite, "nom" : nom, "unites_principales" : unites_principales, "unites_secondaires" : unites_secondaires, "ordre" : ordre, } # Récupération des activités req = """SELECT IDactivite, nom, portail_reservations_limite, portail_reservations_absenti FROM activites;""" DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() self.dictActivites = {} for IDactivite, nom, portail_reservations_limite, portail_reservations_absenti in listeDonnees : self.dictActivites[IDactivite] = { "nom" : nom, "portail_reservations_limite" : portail_reservations_limite, "portail_reservations_absenti" : portail_reservations_absenti, } DB.Close()
def ConvertParametresEnDict(texte=""): dictDonnees = {} if texte in ("", None) : return dictDonnees listeDonnees = texte.split("##") for donnee in listeDonnees : champ, valeur = donnee.split(":=") if champ == "ETIQUETTES" and valeur != None : etiquettes = UTILS_Texte.ConvertStrToListe(valeur) dictDonnees["etiquettes"] = etiquettes if champ == "ETAT" and valeur != None : dictDonnees["etat"] = valeur if champ == "QUANTITE" and valeur != None : dictDonnees["quantite"] = int(valeur) if champ == "HEUREDEBUT" and valeur != None : dictDonnees["heure_debut"] = valeur if champ == "HEUREFIN" and valeur != None : dictDonnees["heure_fin"] = valeur return dictDonnees
def SetIDcoches(self, listeIDcoches=[]): if type(listeIDcoches) == str: listeIDcoches = UTILS_Texte.ConvertStrToListe(listeIDcoches) index = 0 for index, IDcategorie in self.dictCategories.iteritems(): if IDcategorie in listeIDcoches: self.Check(index)
def GetEtiquettes(self): if self.check_etiquettes.GetValue() == True: texteEtiquettes = UTILS_Texte.ConvertListeToStr( self.ctrl_etiquettes.GetCoches()) else: texteEtiquettes = None return texteEtiquettes
def GetCategories(categories_tarifs): listeTemp = [] for IDcategorie in UTILS_Texte.ConvertStrToListe( categories_tarifs): if self.dictCategories.has_key(IDcategorie): listeTemp.append(self.dictCategories[IDcategorie]) return ", ".join(listeTemp)
def GetIDcoches(self): listeIDcoches = [] for index, IDcategorie in self.dictCategories.iteritems(): if self.IsChecked(index): listeIDcoches.append(IDcategorie) listeIDcoches = UTILS_Texte.ConvertListeToStr(listeIDcoches) return listeIDcoches
def Importation_tarifs(self, IDcategorie_tarif=0): if IDcategorie_tarif == None : return [] DB = GestionDB.DB() # Recherche les tarifs dictIndividus = {} req = """SELECT IDtarif, tarifs.IDactivite, tarifs.IDnom_tarif, noms_tarifs.nom, date_debut, date_fin, methode, categories_tarifs, groupes FROM tarifs LEFT JOIN noms_tarifs ON tarifs.IDnom_tarif = noms_tarifs.IDnom_tarif ORDER BY noms_tarifs.nom, date_debut;""" DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() listeTarifs = [] for IDtarif, IDactivite, IDnom_tarif, nomTarif, date_debut, date_fin, methode, categories_tarifs, groupes in listeDonnees : date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) date_fin = UTILS_Dates.DateEngEnDateDD(date_fin) listeCategoriesTarifs = UTILS_Texte.ConvertStrToListe(categories_tarifs) dictTemp = { "IDtarif" : IDtarif, "IDactivite" : IDactivite, "IDnom_tarif" : IDnom_tarif, "nomTarif" : nomTarif, "date_debut" : date_debut, "date_fin" : date_fin, "methode" : methode, "categories_tarifs":categories_tarifs, "groupes":groupes, } if listeCategoriesTarifs != None : if IDcategorie_tarif in listeCategoriesTarifs : listeTarifs.append(dictTemp) return listeTarifs
def SetEtiquettes(self, etiquettes=None): if etiquettes not in (None, ""): etiquettes = UTILS_Texte.ConvertStrToListe(etiquettes) self.ctrl_etiquettes.SetCoches(etiquettes) self.check_etiquettes.SetValue(True) else: self.check_etiquettes.SetValue(False) self.OnCheckEtiquettes(None)
def GetDonnees(self): """ Récupération des données """ conditions = self.ctrl_conditions.GetValeur() if self.radio_heure_debut_fixe.GetValue() == True: heure_debut = self.ctrl_heure_debut.GetHeure() else: heure_debut = "FORMULE:" + self.ctrl_heure_debut_formule.GetValue() if self.radio_heure_fin_fixe.GetValue() == True: heure_fin = self.ctrl_heure_fin.GetHeure() else: heure_fin = "FORMULE:" + self.ctrl_heure_fin_formule.GetValue() etiquettes = self.ctrl_etiquettes.GetCoches() etat = self.ctrl_etat.GetValeur() quantite = self.ctrl_quantite.GetValue() # Conversion en str etiquettesStr = "ETIQUETTES:=" if etiquettes == []: etiquettesStr += "" else: etiquettesStr += UTILS_Texte.ConvertListeToStr(etiquettes) quantiteStr = "QUANTITE:=%d" % quantite heure_debutStr = "HEUREDEBUT:=" if heure_debut == None: heure_debutStr += "" else: heure_debutStr += heure_debut heure_finStr = "HEUREFIN:=" if heure_fin == None: heure_finStr += "" else: heure_finStr += heure_fin etatStr = "ETAT:=%s" % etat listeTemp = (etiquettesStr, etatStr, quantiteStr, heure_debutStr, heure_finStr) parametres = "##".join(listeTemp) # Mémorisation dictDonnees = { "heure_debut": heure_debut, "heure_fin": heure_fin, "etiquettes": etiquettes, "etat": etat, "quantite": quantite, "conditions": conditions, "parametres": parametres, } return dictDonnees
def GetProchainRUM(self): """ Recherche le prochain RUM pour un nouveau mandat """ DB = GestionDB.DB() req = """SELECT IDmandat, rum FROM mandats ORDER BY IDmandat DESC;""" DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() if len(listeDonnees) == 0 : dernierRum = "0" else : IDmandat, dernierRum = listeDonnees[0] if dernierRum == None : dernierRum = "0" rum = UTILS_Texte.Incrementer(dernierRum) return rum
def MAJ(self): if type(self.categories) == str: self.categories = UTILS_Texte.ConvertStrToListe(self.categories) # Génération du texte Catégories listeTemp = [] for IDcategorie in self.categories: nom = None if IDcategorie == 0: nom = _(u"Toutes les catégories inutilisées") if self.parent.dictCategories.has_key(IDcategorie): nom = self.parent.dictCategories[IDcategorie] if nom != None: listeTemp.append(nom) listeTemp.sort() self.texte_categories = u", ".join(listeTemp)
def CreerMode(self): """ Créer un mode 'Remboursement' """ # Vérifie si un mode Remboursement n'existe pas déj� DB = GestionDB.DB() req = """SELECT IDmode, label FROM modes_reglements;""" DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() present = False for IDmode, label in listeDonnees: if "remboursement" in UTILS_Texte.Supprime_accent(label.lower()): present = True if present == True: dlg = wx.MessageDialog( self, _(u"Il semblerait qu'un mode 'Remboursement' soit déjà présent.\n\nSouhaitez-vous quand même créer un nouveau mode ?" ), _(u"Avertissement"), wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_EXCLAMATION) reponse = dlg.ShowModal() dlg.Destroy() if reponse != wx.ID_YES: return # Confirmation dlg = wx.MessageDialog( self, _(u"Confirmez-vous la création d'un mode de règlement 'Remboursement' ?" ), _(u"Confirmation"), wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_QUESTION) reponse = dlg.ShowModal() dlg.Destroy() if reponse != wx.ID_YES: return # Sauvegarde DB = GestionDB.DB() listeDonnees = [ ("label", _(u"Remboursement")), ] IDmode = DB.ReqInsert("modes_reglements", listeDonnees) DB.Close() # MAJ Contrôle Modes self.ctrl_mode.MAJ() self.SelectModeRemboursement()
def RechercheNbreConsoAssociees(self): """ Recherche si les IDetiquette données sont déjà associées à des consommations """ DB = GestionDB.DB() req = """SELECT IDconso, etiquettes FROM consommations WHERE etiquettes IS NOT NULL or etiquettes='';""" DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() dictResultats = {} for IDconso, etiquettes in listeDonnees: etiquettes = UTILS_Texte.ConvertStrToListe(etiquettes) for IDetiquette in etiquettes: if dictResultats.has_key(IDetiquette) == False: dictResultats[IDetiquette] = 0 dictResultats[IDetiquette] += 1 return dictResultats
def SetParametres(self, texte=""): if texte in ("", None) : return listeDonnees = texte.split("##") for donnee in listeDonnees : champ, valeur = donnee.split(":=") if champ == "ETIQUETTES" and valeur != None : etiquettes = UTILS_Texte.ConvertStrToListe(valeur) self.ctrl_etiquettes.SetCoches(etiquettes) if champ == "ETAT" and valeur != None : self.ctrl_etat.SetValeur(valeur) if champ == "QUANTITE" and valeur != None : self.ctrl_quantite.SetValue(int(valeur)) if champ == "HEUREDEBUT" and valeur != None : heure_debut = valeur if "FORMULE:" in heure_debut : self.radio_heure_debut_formule.SetValue(True) heure_debut = heure_debut.replace("FORMULE:", "") self.ctrl_heure_debut_formule.SetValue(heure_debut) else : self.radio_heure_debut_fixe.SetValue(True) if heure_debut not in (None, "") : self.ctrl_heure_debut.SetHeure(heure_debut) if champ == "HEUREFIN" and valeur != None : heure_fin = valeur if "FORMULE:" in heure_fin : self.radio_heure_fin_formule.SetValue(True) heure_fin = heure_fin.replace("FORMULE:", "") self.ctrl_heure_fin_formule.SetValue(heure_fin) else : self.radio_heure_fin_fixe.SetValue(True) if heure_fin not in (None, "") : self.ctrl_heure_fin.SetHeure(heure_fin) # Init contrôles self.OnRadioHeureDebut(None) self.OnRadioHeureFin(None)
def Importation(self): """ Importation des valeurs """ db = GestionDB.DB() req = """SELECT IDunite_remplissage, nom, abrege, seuil_alerte, date_debut, date_fin, heure_min, heure_max, afficher_page_accueil, afficher_grille_conso, etiquettes FROM unites_remplissage WHERE IDunite_remplissage=%d;""" % self.IDunite_remplissage db.ExecuterReq(req) listeTemp = db.ResultatReq() db.Close() if len(listeTemp) == 0: return listeTemp = listeTemp[0] nom = listeTemp[1] abrege = listeTemp[2] seuil_alerte = listeTemp[3] date_debut = listeTemp[4] date_fin = listeTemp[5] heure_min = listeTemp[6] heure_max = listeTemp[7] afficher_page_accueil = listeTemp[8] afficher_grille_conso = listeTemp[9] etiquettes = listeTemp[10] self.ctrl_nom.SetValue(nom) self.ctrl_abrege.SetValue(abrege) self.ctrl_seuil.SetValue(seuil_alerte) self.ctrl_heure_min.SetHeure(heure_min) self.ctrl_heure_max.SetHeure(heure_max) if date_debut != "1977-01-01" and date_fin != "2999-01-01": self.ctrl_date_debut.SetDate(date_debut) self.ctrl_date_fin.SetDate(date_fin) self.radio_limitee.SetValue(True) if afficher_page_accueil == 0: self.check_afficher_page_accueil.SetValue(False) if afficher_grille_conso == 0: self.check_afficher_grille_conso.SetValue(False) self.ctrl_etiquettes.SetCoches( UTILS_Texte.ConvertStrToListe(etiquettes)) self.ctrl_unites.Importation()
def SelectModeRemboursement(self): for index, dictTemp in self.ctrl_mode.dictDonnees.iteritems(): if "remboursement" in UTILS_Texte.Supprime_accent( dictTemp["label"].lower()): self.ctrl_mode.SetID(dictTemp["ID"])
def Importation(self): DB = GestionDB.DB() if len(self.listeGroupes) == 0: conditionGroupes = "()" elif len(self.listeGroupes) == 1: conditionGroupes = "(%d)" % self.listeGroupes[0] else: conditionGroupes = str(tuple(self.listeGroupes)) if self.affichage_mode == "reservation": if len(self.affichage_etat) == 0: conditionEtat = "()" elif len(self.affichage_etat) == 1: conditionEtat = "('%s')" % self.affichage_etat[0] else: conditionEtat = str(tuple(self.affichage_etat)) elif self.affichage_mode == "attente": conditionEtat = "('attente')" elif self.affichage_mode == "refus": conditionEtat = "('refus')" else: conditionEtat = "()" # Unités req = """SELECT IDunite, nom, abrege FROM unites WHERE IDactivite=%d ORDER BY ordre;""" % self.IDactivite DB.ExecuterReq(req) listeUnites = DB.ResultatReq() # Groupes req = """SELECT IDgroupe, nom, abrege FROM groupes WHERE IDactivite=%d ORDER BY ordre;""" % self.IDactivite DB.ExecuterReq(req) listeGroupes = DB.ResultatReq() # Evènements self.dictEvenements = {} req = """SELECT IDevenement, nom, date FROM evenements WHERE IDactivite=%d AND date>='%s' AND date<='%s' ;""" % (self.IDactivite, self.date_debut, self.date_fin) DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() for IDevenement, nom, date in listeDonnees: date = UTILS_Dates.DateEngEnDateDD(date) self.dictEvenements[IDevenement] = {"nom": nom, "date": date} # Etiquettes self.dictEtiquettes = {} req = """SELECT IDetiquette, label, IDactivite, parent, ordre, couleur FROM etiquettes;""" DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() for IDetiquette, label, IDactivite, parent, ordre, couleur in listeDonnees: couleurTemp = couleur[1:-1].split(",") couleur = wx.Colour(int(couleurTemp[0]), int(couleurTemp[1]), int(couleurTemp[2])) self.dictEtiquettes[IDetiquette] = { "label": label, "IDactivite": IDactivite, "parent": parent, "ordre": ordre, "couleur": couleur } # Consommations req = """SELECT IDconso, consommations.date, consommations.IDindividu, consommations.IDunite, consommations.IDgroupe, consommations.IDactivite, consommations.etiquettes, heure_debut, heure_fin, etat, quantite, IDevenement, consommations.IDprestation, prestations.temps_facture, comptes_payeurs.IDfamille, activites.nom, groupes.nom, categories_tarifs.nom FROM consommations LEFT JOIN prestations ON prestations.IDprestation = consommations.IDprestation LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = consommations.IDcompte_payeur LEFT JOIN activites ON activites.IDactivite = consommations.IDactivite LEFT JOIN groupes ON groupes.IDgroupe = consommations.IDgroupe LEFT JOIN categories_tarifs ON categories_tarifs.IDcategorie_tarif = consommations.IDcategorie_tarif WHERE consommations.IDactivite=%d AND consommations.IDgroupe IN %s AND consommations.date>='%s' AND consommations.date<='%s' AND etat IN %s ;""" % (self.IDactivite, conditionGroupes, self.date_debut, self.date_fin, conditionEtat) DB.ExecuterReq(req) listeConsommations = DB.ResultatReq() DB.Close() # Calcul des données dictResultats = {} listePrestationsTraitees = [] for IDconso, date, IDindividu, IDunite, IDgroupe, IDactivite, etiquettes, heure_debut, heure_fin, etat, quantite, IDevenement, IDprestation, tempsFacture, IDfamille, nomActivite, nomGroupe, nomCategorie in listeConsommations: date = DateEngEnDateDD(date) mois = date.month annee = date.year # Recherche du regroupement try: if self.affichage_regroupement == "jour": regroupement = date if self.affichage_regroupement == "mois": regroupement = (annee, mois) if self.affichage_regroupement == "annee": regroupement = annee if self.affichage_regroupement == "activite": regroupement = nomActivite if self.affichage_regroupement == "groupe": regroupement = nomGroupe if self.affichage_regroupement == "evenement": regroupement = IDevenement if self.affichage_regroupement == "evenement_date": regroupement = IDevenement if self.affichage_regroupement == "categorie_tarif": regroupement = nomCategorie if self.affichage_regroupement == "ville_residence": regroupement = self.dictInfosIndividus[IDindividu][ "INDIVIDU_VILLE"] if self.affichage_regroupement == "secteur": regroupement = self.dictInfosIndividus[IDindividu][ "INDIVIDU_SECTEUR"] if self.affichage_regroupement == "genre": regroupement = self.dictInfosIndividus[IDindividu][ "INDIVIDU_SEXE"] if self.affichage_regroupement == "age": regroupement = self.dictInfosIndividus[IDindividu][ "INDIVIDU_AGE_INT"] if self.affichage_regroupement == "ville_naissance": regroupement = self.dictInfosIndividus[IDindividu][ "INDIVIDU_VILLE_NAISS"] if self.affichage_regroupement == "nom_ecole": regroupement = self.dictInfosIndividus[IDindividu][ "SCOLARITE_NOM_ECOLE"] if self.affichage_regroupement == "nom_classe": regroupement = self.dictInfosIndividus[IDindividu][ "SCOLARITE_NOM_CLASSE"] if self.affichage_regroupement == "nom_niveau_scolaire": regroupement = self.dictInfosIndividus[IDindividu][ "SCOLARITE_NOM_NIVEAU"] if self.affichage_regroupement == "famille": regroupement = self.dictInfosFamilles[IDfamille][ "FAMILLE_NOM"] if self.affichage_regroupement == "individu": regroupement = self.dictInfosIndividus[IDindividu][ "INDIVIDU_NOM_COMPLET"] if self.affichage_regroupement == "regime": regroupement = self.dictInfosFamilles[IDfamille][ "FAMILLE_NOM_REGIME"] if self.affichage_regroupement == "caisse": regroupement = self.dictInfosFamilles[IDfamille][ "FAMILLE_NOM_CAISSE"] if self.affichage_regroupement == "categorie_travail": regroupement = self.dictInfosIndividus[IDindividu][ "INDIVIDU_CATEGORIE_TRAVAIL"] if self.affichage_regroupement == "categorie_travail_pere": regroupement = self.dictInfosIndividus[IDindividu][ "PERE_CATEGORIE_TRAVAIL"] if self.affichage_regroupement == "categorie_travail_mere": regroupement = self.dictInfosIndividus[IDindividu][ "MERE_CATEGORIE_TRAVAIL"] # QF if self.affichage_regroupement == "qf": regroupement = None qf = self.dictInfosFamilles[IDfamille][ "FAMILLE_QF_ACTUEL_INT"] for x in range(0, 10000, 100): min, max = x, x + 99 if qf >= min and qf <= max: regroupement = (min, max) # Etiquettes if self.affichage_regroupement == "etiquette": etiquettes = UTILS_Texte.ConvertStrToListe(etiquettes) if len(etiquettes) > 0: temp = [] for IDetiquette in etiquettes: if self.dictEtiquettes.has_key(IDetiquette): temp.append( self.dictEtiquettes[IDetiquette]["label"]) regroupement = temp else: regroupement = _(u"- Aucune étiquette -") # Questionnaires if self.affichage_regroupement.startswith( "question_" ) and "famille" in self.affichage_regroupement: regroupement = self.dictInfosFamilles[IDfamille][ "QUESTION_%s" % self.affichage_regroupement[17:]] if self.affichage_regroupement.startswith( "question_" ) and "individu" in self.affichage_regroupement: regroupement = self.dictInfosIndividus[IDindividu][ "QUESTION_%s" % self.affichage_regroupement[18:]] except: regroupement = None if regroupement in ("", None): regroupement = _(u"- Non renseigné -") # Quantité if quantite == None: quantite = 1 # Formatage des heures if heure_debut != None and heure_debut != "": h, m = heure_debut.split(":") heure_debut = datetime.time(int(h), int(m)) if heure_fin != None and heure_fin != "": h, m = heure_fin.split(":") heure_fin = datetime.time(int(h), int(m)) # Calcul du temps temps_presence = datetime.timedelta(hours=0, minutes=0) if heure_debut != None and heure_debut != "" and heure_fin != None and heure_fin != "": valeur = datetime.timedelta( hours=heure_fin.hour, minutes=heure_fin.minute) - datetime.timedelta( hours=heure_debut.hour, minutes=heure_debut.minute) temps_presence += valeur # Si c'est en fonction du temps facturé temps_facture = datetime.timedelta(hours=0, minutes=0) if tempsFacture != None and tempsFacture != "": if IDprestation not in listePrestationsTraitees: hr, mn = tempsFacture.split(":") temps_facture += datetime.timedelta(hours=int(hr), minutes=int(mn)) listePrestationsTraitees.append(IDprestation) if self.detail_groupes == True: groupe = IDgroupe else: groupe = None if self.affichage_donnees == "quantite": valeur = quantite if self.affichage_donnees == "temps_presence": valeur = temps_presence if self.affichage_donnees == "temps_facture": valeur = temps_facture if self.affichage_donnees == "quantite": defaut = 0 else: defaut = datetime.timedelta(hours=0, minutes=0) # En cas de regroupements multiples : if type(regroupement) == list: listeRegroupements = regroupement else: listeRegroupements = [ regroupement, ] for regroupement in listeRegroupements: if dictResultats.has_key(groupe) == False: dictResultats[groupe] = {} if dictResultats[groupe].has_key(IDunite) == False: dictResultats[groupe][IDunite] = {} if dictResultats[groupe][IDunite].has_key( regroupement) == False: dictResultats[groupe][IDunite][regroupement] = defaut dictResultats[groupe][IDunite][regroupement] += valeur return dictResultats, listeUnites, listeGroupes
def GetXMLSepa(dictDonnees): """ Génération du fichier XML SEPA """ doc = Document() # Variables principales type_remise = dictDonnees["type_remise"] nom_fichier = dictDonnees["nom_fichier"] remise_nom = dictDonnees["remise_nom"] remise_date_heure = dictDonnees["remise_date_heure"] remise_nbre = dictDonnees["remise_nbre"] remise_montant = dictDonnees["remise_montant"] creancier_nom = dictDonnees["creancier_nom"] creancier_rue = dictDonnees["creancier_rue"] creancier_cp = dictDonnees["creancier_cp"] creancier_ville = dictDonnees["creancier_ville"] creancier_pays = dictDonnees["creancier_pays"] creancier_siret = dictDonnees["creancier_siret"] listeLots = dictDonnees["lots"] # Génération du document XML racine = doc.createElement("Document") racine.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance") racine.setAttribute("xmlns", "urn:iso:std:iso:20022:tech:xsd:pain.008.001.02") doc.appendChild(racine) # CstmrDrctDbtInitn CstmrDrctDbtInitn = doc.createElement("CstmrDrctDbtInitn") racine.appendChild(CstmrDrctDbtInitn) # ----------------------------------------------------------- NIVEAU MESSAGE ------------------------------------------------------------------------------ # ------------- Caractéristiques générales du prélèvement ------------------- # GrpHdr GrpHdr = doc.createElement("GrpHdr") CstmrDrctDbtInitn.appendChild(GrpHdr) # MsgId MsgId = doc.createElement("MsgId") GrpHdr.appendChild(MsgId) if type_remise == "public_dft": MsgId.appendChild(doc.createTextNode(nom_fichier)) else: MsgId.appendChild(doc.createTextNode(remise_nom)) # CreDtTm CreDtTm = doc.createElement("CreDtTm") GrpHdr.appendChild(CreDtTm) CreDtTm.appendChild(doc.createTextNode(remise_date_heure)) # NbOfTxs NbOfTxs = doc.createElement("NbOfTxs") GrpHdr.appendChild(NbOfTxs) NbOfTxs.appendChild(doc.createTextNode(remise_nbre)) # CtrlSum CtrlSum = doc.createElement("CtrlSum") GrpHdr.appendChild(CtrlSum) CtrlSum.appendChild(doc.createTextNode(remise_montant)) # ------------- Créantier (organisateur) ------------------- # InitgPty InitgPty = doc.createElement("InitgPty") GrpHdr.appendChild(InitgPty) # Nm Nm = doc.createElement("Nm") InitgPty.appendChild(Nm) Nm.appendChild(doc.createTextNode(creancier_nom[:70])) # Id Id = doc.createElement("Id") InitgPty.appendChild(Id) # OrgId OrgId = doc.createElement("OrgId") Id.appendChild(OrgId) # Othr Othr = doc.createElement("Othr") OrgId.appendChild(Othr) # Id Id = doc.createElement("Id") Othr.appendChild(Id) Id.appendChild(doc.createTextNode(creancier_siret)) # SchmeNm SchmeNm = doc.createElement("SchmeNm") Othr.appendChild(SchmeNm) # Prtry Prtry = doc.createElement("Prtry") SchmeNm.appendChild(Prtry) Prtry.appendChild(doc.createTextNode("SIRET")) # ----------------------------------------------------------- NIVEAU LOT ------------------------------------------------------------------------------ for dictLot in listeLots: lot_nom = dictLot["lot_nom"] lot_nbre = dictLot["lot_nbre"] lot_montant = dictLot["lot_montant"] lot_date = dictLot["lot_date"] lot_iban = dictLot["lot_iban"] lot_bic = dictLot["lot_bic"] lot_ics = dictLot["lot_ics"] lot_dft_titulaire = dictLot["dft_titulaire"] lot_dft_iban = dictLot["dft_iban"] lot_motif = dictLot["motif"] lot_sequence = dictLot["lot_sequence"] listeTransactions = dictLot["transactions"] # PmtInf PmtInf = doc.createElement("PmtInf") CstmrDrctDbtInitn.appendChild(PmtInf) # PmtInfId PmtInfId = doc.createElement("PmtInfId") PmtInf.appendChild(PmtInfId) PmtInfId.appendChild(doc.createTextNode(lot_nom)) # PmtMtd PmtMtd = doc.createElement("PmtMtd") PmtInf.appendChild(PmtMtd) PmtMtd.appendChild(doc.createTextNode("DD")) # NbOfTxs NbOfTxs = doc.createElement("NbOfTxs") PmtInf.appendChild(NbOfTxs) NbOfTxs.appendChild(doc.createTextNode(lot_nbre)) # CtrlSum CtrlSum = doc.createElement("CtrlSum") PmtInf.appendChild(CtrlSum) CtrlSum.appendChild(doc.createTextNode(lot_montant)) # PmtTpInf PmtTpInf = doc.createElement("PmtTpInf") PmtInf.appendChild(PmtTpInf) # SvcLvl SvcLvl = doc.createElement("SvcLvl") PmtTpInf.appendChild(SvcLvl) # Cd Cd = doc.createElement("Cd") SvcLvl.appendChild(Cd) Cd.appendChild(doc.createTextNode("SEPA")) # LclInstrm LclInstrm = doc.createElement("LclInstrm") PmtTpInf.appendChild(LclInstrm) # Cd Cd = doc.createElement("Cd") LclInstrm.appendChild(Cd) Cd.appendChild(doc.createTextNode("CORE")) # SeqTp SeqTp = doc.createElement("SeqTp") PmtTpInf.appendChild(SeqTp) SeqTp.appendChild(doc.createTextNode(lot_sequence)) # ReqdColltnDt ReqdColltnDt = doc.createElement("ReqdColltnDt") PmtInf.appendChild(ReqdColltnDt) ReqdColltnDt.appendChild(doc.createTextNode(lot_date)) # Cdtr Cdtr = doc.createElement("Cdtr") PmtInf.appendChild(Cdtr) if type_remise == "prive": # Cdtr Nm = doc.createElement("Nm") Cdtr.appendChild(Nm) Nm.appendChild(doc.createTextNode(creancier_nom)) if type_remise == "public_dft": perception = dictDonnees["perception"] # Cdtr Nm = doc.createElement("Nm") Cdtr.appendChild(Nm) Nm.appendChild(doc.createTextNode(perception["nom"])) # PstlAdr PstlAdr = doc.createElement("PstlAdr") Cdtr.appendChild(PstlAdr) # Ctry Ctry = doc.createElement("Ctry") PstlAdr.appendChild(Ctry) Ctry.appendChild(doc.createTextNode("FR")) # AdrLine AdrLine = doc.createElement("AdrLine") PstlAdr.appendChild(AdrLine) AdrLine.appendChild(doc.createTextNode(perception["rue_resid"])) # AdrLine AdrLine = doc.createElement("AdrLine") PstlAdr.appendChild(AdrLine) AdrLine.appendChild( doc.createTextNode( u"%s %s" % (perception["cp_resid"], perception["ville_resid"]))) # CdtrAcct CdtrAcct = doc.createElement("CdtrAcct") PmtInf.appendChild(CdtrAcct) # Id Id = doc.createElement("Id") CdtrAcct.appendChild(Id) # IBAN IBAN = doc.createElement("IBAN") Id.appendChild(IBAN) IBAN.appendChild(doc.createTextNode(lot_iban)) # CdtrAgt CdtrAgt = doc.createElement("CdtrAgt") PmtInf.appendChild(CdtrAgt) # FinInstnId FinInstnId = doc.createElement("FinInstnId") CdtrAgt.appendChild(FinInstnId) # BIC BIC = doc.createElement("BIC") FinInstnId.appendChild(BIC) BIC.appendChild(doc.createTextNode(lot_bic)) if type_remise == "public_dft": # UltmtCdtr UltmtCdtr = doc.createElement("UltmtCdtr") PmtInf.appendChild(UltmtCdtr) # Nm Nm = doc.createElement("Nm") UltmtCdtr.appendChild(Nm) Nm.appendChild(doc.createTextNode(lot_dft_titulaire)) # Id Id = doc.createElement("Id") UltmtCdtr.appendChild(Id) # OrgId OrgId = doc.createElement("OrgId") Id.appendChild(OrgId) # Othr Othr = doc.createElement("Othr") OrgId.appendChild(Othr) # Id Id = doc.createElement("Id") Othr.appendChild(Id) Id.appendChild(doc.createTextNode(lot_dft_iban)) # ChrgBr ChrgBr = doc.createElement("ChrgBr") PmtInf.appendChild(ChrgBr) ChrgBr.appendChild(doc.createTextNode("SLEV")) # CdtrSchmeId CdtrSchmeId = doc.createElement("CdtrSchmeId") PmtInf.appendChild(CdtrSchmeId) # Id Id = doc.createElement("Id") CdtrSchmeId.appendChild(Id) # PrvtId PrvtId = doc.createElement("PrvtId") Id.appendChild(PrvtId) # Othr Othr = doc.createElement("Othr") PrvtId.appendChild(Othr) # Id Id = doc.createElement("Id") Othr.appendChild(Id) Id.appendChild(doc.createTextNode(lot_ics)) # SchmeNm SchmeNm = doc.createElement("SchmeNm") Othr.appendChild(SchmeNm) # Prtry Prtry = doc.createElement("Prtry") SchmeNm.appendChild(Prtry) Prtry.appendChild(doc.createTextNode("SEPA")) # ----------------------------------------------------------- NIVEAU TRANSACTION ------------------------------------------------------------------------------ for dictTransaction in listeTransactions: transaction_id = dictTransaction["transaction_id"] transaction_montant = dictTransaction["transaction_montant"] transaction_mandat_id = dictTransaction["transaction_mandat_id"] transaction_mandat_date = dictTransaction[ "transaction_mandat_date"] transaction_bic = dictTransaction["transaction_bic"] transaction_debiteur = dictTransaction["transaction_debiteur"] transaction_iban = dictTransaction["transaction_iban"] # DrctDbtTxInf DrctDbtTxInf = doc.createElement("DrctDbtTxInf") PmtInf.appendChild(DrctDbtTxInf) # PmtId PmtId = doc.createElement("PmtId") DrctDbtTxInf.appendChild(PmtId) # EndToEndId EndToEndId = doc.createElement("EndToEndId") PmtId.appendChild(EndToEndId) if type_remise == "public_dft": endtoend = "1D%s0%s" % (dictDonnees["poste_comptable"], transaction_id) EndToEndId.appendChild(doc.createTextNode(endtoend)) else: EndToEndId.appendChild(doc.createTextNode(transaction_id)) # InstdAmt InstdAmt = doc.createElement("InstdAmt") DrctDbtTxInf.appendChild(InstdAmt) InstdAmt.appendChild(doc.createTextNode(transaction_montant)) InstdAmt.setAttribute("Ccy", "EUR") # DrctDbtTx DrctDbtTx = doc.createElement("DrctDbtTx") DrctDbtTxInf.appendChild(DrctDbtTx) # MndtRltdInf MndtRltdInf = doc.createElement("MndtRltdInf") DrctDbtTx.appendChild(MndtRltdInf) # MndtId MndtId = doc.createElement("MndtId") MndtRltdInf.appendChild(MndtId) MndtId.appendChild(doc.createTextNode(transaction_mandat_id)) # DtOfSgntr DtOfSgntr = doc.createElement("DtOfSgntr") MndtRltdInf.appendChild(DtOfSgntr) DtOfSgntr.appendChild(doc.createTextNode(transaction_mandat_date)) # AmdmntInd AmdmntInd = doc.createElement("AmdmntInd") MndtRltdInf.appendChild(AmdmntInd) AmdmntInd.appendChild(doc.createTextNode("false")) # DbtrAgt DbtrAgt = doc.createElement("DbtrAgt") DrctDbtTxInf.appendChild(DbtrAgt) # FinInstnId FinInstnId = doc.createElement("FinInstnId") DbtrAgt.appendChild(FinInstnId) # Dbtr BIC = doc.createElement("BIC") FinInstnId.appendChild(BIC) BIC.appendChild(doc.createTextNode(transaction_bic)) # Dbtr Dbtr = doc.createElement("Dbtr") DrctDbtTxInf.appendChild(Dbtr) # Nm Nm = doc.createElement("Nm") Dbtr.appendChild(Nm) Nm.appendChild( doc.createTextNode( UTILS_Texte.Supprime_accent(transaction_debiteur[:70]))) # DbtrAcct DbtrAcct = doc.createElement("DbtrAcct") DrctDbtTxInf.appendChild(DbtrAcct) # Id Id = doc.createElement("Id") DbtrAcct.appendChild(Id) # IBAN IBAN = doc.createElement("IBAN") Id.appendChild(IBAN) IBAN.appendChild(doc.createTextNode(transaction_iban)) if type_remise == "public_dft": # RmtInf RmtInf = doc.createElement("RmtInf") DrctDbtTxInf.appendChild(RmtInf) # Ustrd Ustrd = doc.createElement("Ustrd") RmtInf.appendChild(Ustrd) Ustrd.appendChild(doc.createTextNode(lot_motif)) return doc
def Sauvegarde(self): # Récupération des tracks liste_tracks = self.ctrl_listview.GetTracksCoches() # Récupération des paramètres IDtype_cotisation = self.ctrl_parametres.ctrl_type.GetID() IDunite_cotisation = self.ctrl_parametres.ctrl_unite.GetID() date_saisie = self.ctrl_parametres.date_saisie IDutilisateur = self.ctrl_parametres.IDutilisateur date_debut = self.ctrl_parametres.ctrl_date_debut.GetDate() date_fin = self.ctrl_parametres.ctrl_date_fin.GetDate() activites = self.ctrl_parametres.ctrl_activites.GetDonnees( format="texte") observations = self.ctrl_parametres.ctrl_observations.GetValue() type_cotisation = self.ctrl_parametres.ctrl_type.GetDetailDonnees( )["type"] # Vérifie que les cotisations n'existent pas déj� liste_IDindividu = [ track.IDindividu for track in liste_tracks if track.IDindividu != None ] if len(liste_IDindividu) == 1: condition_individus = "AND cotisations.IDindividu == %d" % liste_IDindividu[ 0] elif len(liste_IDindividu) > 1: condition_individus = "AND cotisations.IDindividu IN %s" % str( tuple(liste_IDindividu)) else: condition_individus = "" liste_IDfamille = [ track.IDfamille for track in liste_tracks if track.IDfamille != None ] if len(liste_IDfamille) == 1: condition_familles = "AND cotisations.IDfamille == %d" % liste_IDfamille[ 0] elif len(liste_IDfamille) > 1: condition_familles = "AND cotisations.IDfamille IN %s" % str( tuple(liste_IDfamille)) else: condition_familles = "" DB = GestionDB.DB() req = """SELECT IDcotisation, IDfamille, cotisations.IDindividu, numero, individus.prenom, individus.nom FROM cotisations LEFT JOIN individus ON individus.IDindividu = cotisations.IDindividu WHERE IDtype_cotisation=%d AND IDunite_cotisation=%d %s %s;""" % (IDtype_cotisation, IDunite_cotisation, condition_individus, condition_familles) DB.ExecuterReq(req) listeCotisationsExistantes = DB.ResultatReq() DB.Close() if len(listeCotisationsExistantes) > 0: dictTitulaires = UTILS_Titulaires.GetTitulaires() liste_details = [] for IDcotisation, IDfamille, IDindividu, numero, prenom_individu, nom_individu in listeCotisationsExistantes: # Si cotisation familiale if IDfamille != None and IDfamille in dictTitulaires: nom_famille = dictTitulaires[IDfamille][ "titulairesSansCivilite"] liste_details.append( _(u"Famille de %s : Cotisation n°%s") % (nom_famille, numero)) # Si cotisation individuelle if IDindividu != None: if prenom_individu == None: prenom_individu = "" liste_details.append( _(u"%s %s : Cotisation n°%s") % (nom_individu, prenom_individu, numero)) # Demande si on continue ou non intro = _( u"Les cotisations suivantes existent déjà avec le même type et la même unité de cotisation :" ) conclusion = _( u"Souhaitez-vous quand même les générer une nouvelle fois ?" ) detail = "\n".join(liste_details) dlg = DLG_Messagebox.Dialog( self, titre=_(u"Avertissement"), introduction=intro, detail=detail, conclusion=conclusion, icone=wx.ICON_EXCLAMATION, boutons=[_(u"Oui"), _(u"Non"), _(u"Annuler")]) reponse = dlg.ShowModal() dlg.Destroy() if reponse in (1, 2): return False # Création de la carte if self.ctrl_parametres.ctrl_creation.GetValue() == True: numero_manuel = self.ctrl_parametres.radio_numero_manuel.GetValue() date_creation_carte = self.ctrl_parametres.ctrl_date_creation.GetDate( ) numero = self.ctrl_parametres.ctrl_numero.GetValue() else: numero_manuel = False date_creation_carte = None numero = None # Confirmation dlg = wx.MessageDialog( self, _(u"Confirmez-vous la génération de %d cotisations ?") % len(liste_tracks), _(u"Confirmation"), wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION) reponse = dlg.ShowModal() dlg.Destroy() if reponse != wx.ID_YES: return False # Sauvegarde DB = GestionDB.DB() dlgprogress = wx.ProgressDialog(_(u"Génération des cotisations"), _(u"Veuillez patienter..."), maximum=len(liste_tracks), parent=None, style=wx.PD_SMOOTH | wx.PD_AUTO_HIDE | wx.PD_APP_MODAL) index = 1 for track in liste_tracks: dlgprogress.Update( index, _(u"Génération de la cotisation %d sur %d") % (index, len(liste_tracks))) if numero_manuel == True: numero = track.numero if type_cotisation == "famille": IDfamille = track.IDfamille else: IDfamille = None listeDonnees = [ ("IDfamille", IDfamille), ("IDindividu", track.IDindividu), ("IDtype_cotisation", IDtype_cotisation), ("IDunite_cotisation", IDunite_cotisation), ("date_saisie", date_saisie), ("IDutilisateur", IDutilisateur), ("date_creation_carte", date_creation_carte), ("numero", numero), ("date_debut", date_debut), ("date_fin", date_fin), ("observations", observations), ("activites", activites), ] IDcotisation = DB.ReqInsert("cotisations", listeDonnees) # Sauvegarde de la prestation facturer = self.ctrl_parametres.ctrl_facturer.GetValue() date_facturation = self.ctrl_parametres.ctrl_date_prestation.GetDate( ) montant = self.ctrl_parametres.ctrl_montant.GetMontant() label_prestation = self.ctrl_parametres.ctrl_label.GetValue() if facturer == True: # Création d'une prestation listeDonnees = [ ("IDcompte_payeur", track.IDcompte_payeur), ("date", date_facturation), ("categorie", "cotisation"), ("label", label_prestation), ("montant_initial", montant), ("montant", montant), ("IDfamille", track.IDfamille), ("IDindividu", track.IDindividu), ] listeDonnees.append( ("date_valeur", str(datetime.date.today()))) IDprestation = DB.ReqInsert("prestations", listeDonnees) # Insertion du IDprestation dans la cotisation DB.ReqMAJ("cotisations", [ ("IDprestation", IDprestation), ], "IDcotisation", IDcotisation) # Mémorise l'action dans l'historique date_debut_periode = UTILS_Dates.DateEngFr(str(date_debut)) date_fin_periode = UTILS_Dates.DateEngFr(str(date_fin)) UTILS_Historique.InsertActions([ { "IDindividu": track.IDindividu, "IDfamille": track.IDfamille, "IDcategorie": 21, "action": _(u"Saisie de la cotisation ID%d '%s' pour la période du %s au %s" ) % (IDcotisation, label_prestation, date_debut_periode, date_fin_periode), }, ]) # Génération du prochain numéro de cotisation if numero != None: numero = UTILS_Texte.Incrementer(numero) index += 1 DB.Close() dlgprogress.Destroy() # Succès dlg = wx.MessageDialog( self, _(u"Les %d cotisations ont été générées avec succès.") % len(liste_tracks), _(u"Fin"), wx.OK | wx.ICON_INFORMATION) dlg.ShowModal() dlg.Destroy() # MAJ self.ctrl_listview.MAJ() return True
def Importation(self, DBtemp=None): """ Importation depuis la base """ dictValeurs = {} # Lecture de la base if DBtemp == None: DB = GestionDB.DB() else: DB = DBtemp # Informations générales sur le contrat if self.IDcontrat != None: req = """SELECT contrats.IDindividu, IDinscription, date_debut, date_fin, observations, IDactivite, type, duree_absences_prevues, duree_heures_regularisation, arrondi_type, arrondi_delta, duree_tolerance_depassement, planning, individus.nom, individus.prenom FROM contrats LEFT JOIN individus ON individus.IDindividu = contrats.IDindividu WHERE IDcontrat=%d ;""" % self.IDcontrat DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() if len(listeDonnees) > 0: IDindividu, IDinscription, date_debut, date_fin, observations, IDactivite, type_contrat, duree_absences_prevues, duree_heures_regularisation, arrondi_type, arrondi_delta, duree_tolerance_depassement, planning, individu_nom, individu_prenom = listeDonnees[ 0] self.IDinscription = IDinscription dictValeurs["IDinscription"] = self.IDinscription dictValeurs["date_debut"] = UTILS_Dates.DateEngEnDateDD( date_debut) dictValeurs["date_fin"] = UTILS_Dates.DateEngEnDateDD(date_fin) dictValeurs["observations"] = observations dictValeurs["IDactivite"] = IDactivite dictValeurs["type_contrat"] = type_contrat dictValeurs[ "duree_absences_prevues"] = UTILS_Dates.HeureStrEnDelta( duree_absences_prevues) dictValeurs[ "duree_heures_regularisation"] = UTILS_Dates.HeureStrEnDelta( duree_heures_regularisation) dictValeurs[ "duree_tolerance_depassement"] = UTILS_Dates.HeureStrEnDelta( duree_tolerance_depassement) dictValeurs["individu_nom"] = individu_nom dictValeurs["individu_prenom"] = individu_prenom dictValeurs["arrondi_type"] = arrondi_type dictValeurs["arrondi_delta"] = arrondi_delta dictValeurs["planning"] = planning if individu_prenom != None: dictValeurs["individu_nom_complet"] = u"%s %s" % ( individu_nom, individu_prenom) else: dictValeurs["individu_nom_complet"] = individu_nom # Importation des données de l'inscription if self.IDinscription != None: req = """SELECT IDindividu, IDfamille, IDactivite, IDgroupe, IDcategorie_tarif, IDcompte_payeur, date_inscription, parti FROM inscriptions WHERE inscriptions.statut='ok' AND IDinscription=%d ;""" % self.IDinscription DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() IDindividu, IDfamille, IDactivite, IDgroupe, IDcategorie_tarif, IDcompte_payeur, date_inscription, parti = listeDonnees[ 0] dictValeurs["IDinscription"] = self.IDinscription dictValeurs["IDindividu"] = IDindividu dictValeurs["IDfamille"] = IDfamille dictValeurs["IDactivite"] = IDactivite dictValeurs["IDgroupe"] = IDgroupe dictValeurs["IDcategorie_tarif"] = IDcategorie_tarif dictValeurs["IDcompte_payeur"] = IDcompte_payeur dictValeurs["date_inscription"] = date_inscription dictValeurs["parti"] = parti # Infos sur le dernier contrat saisi req = """SELECT arrondi_type, arrondi_delta, duree_tolerance_depassement FROM contrats WHERE type='psu' AND IDactivite=%d ORDER BY IDcontrat DESC LIMIT 1 ;""" % IDactivite DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() if len(listeDonnees) > 0: arrondi_type, arrondi_delta, duree_tolerance_depassement = listeDonnees[ 0] dictValeurs["arrondi_type"] = arrondi_type dictValeurs["arrondi_delta"] = arrondi_delta dictValeurs[ "duree_tolerance_depassement"] = UTILS_Dates.HeureStrEnDelta( duree_tolerance_depassement) # Informations sur l'activité req = """SELECT psu_unite_prevision, psu_unite_presence, psu_tarif_forfait, psu_etiquette_rtt FROM activites WHERE IDactivite=%d ;""" % dictValeurs["IDactivite"] DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() psu_unite_prevision, psu_unite_presence, psu_tarif_forfait, psu_etiquette_rtt = listeDonnees[ 0] dictValeurs["IDunite_prevision"] = psu_unite_prevision dictValeurs["IDunite_presence"] = psu_unite_presence dictValeurs["IDtarif"] = psu_tarif_forfait dictValeurs["psu_etiquette_rtt"] = psu_etiquette_rtt dictValeurs["duree_absences_prises"] = datetime.timedelta(0) # Mémorise les données déjà importées self.SetValeurs(dictValeurs) # Echap sur nouveau contrat if self.IDcontrat == None: DB.Close() return # Lecture des consommations req = """SELECT IDconso, date, IDunite, IDgroupe, heure_debut, heure_fin, consommations.etat, verrouillage, date_saisie, IDutilisateur, IDcategorie_tarif, IDprestation, forfait, quantite, etiquettes FROM consommations WHERE IDinscription=%d AND date>='%s' AND date<='%s' ;""" % (self.IDinscription, dictValeurs["date_debut"], dictValeurs["date_fin"]) DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() tracks_previsions = [] liste_IDconso = [] liste_conso = [] dict_conso = {} for IDconso, date, IDunite, IDgroupe, heure_debut, heure_fin, etat, verrouillage, date_saisie, IDutilisateur, IDcategorie_tarif, IDprestation, forfait, quantite, etiquettes in listeDonnees: date = UTILS_Dates.DateEngEnDateDD(date) date_saisie = UTILS_Dates.DateEngEnDateDD(date_saisie) heure_debut_time = UTILS_Dates.HeureStrEnTime(heure_debut) heure_fin_time = UTILS_Dates.HeureStrEnTime(heure_fin) etiquettes = UTILS_Texte.ConvertStrToListe(etiquettes) dictConso = { "IDconso": IDconso, "date": date, "IDunite": IDunite, "IDgroupe": IDgroupe, "heure_debut": heure_debut, "heure_fin": heure_fin, "etat": etat, "verrouillage": verrouillage, "date_saisie": date_saisie, "IDutilisateur": IDutilisateur, "IDcategorie_tarif": IDcategorie_tarif, "IDprestation": IDprestation, "forfait": forfait, "quantite": quantite, "etiquettes": etiquettes, "heure_debut_time": heure_debut_time, "heure_fin_time": heure_fin_time, } track = Track_conso(self, dictConso) liste_conso.append(track) if (date in dict_conso) == False: dict_conso[date] = [] dict_conso[date].append(track) if IDunite == self.GetValeur("IDunite_prevision", None): tracks_previsions.append(track) liste_IDconso.append(IDconso) if dictValeurs["psu_etiquette_rtt"] in etiquettes: dictValeurs["duree_absences_prises"] += track.duree_arrondie dictValeurs["liste_conso"] = liste_conso dictValeurs["dict_conso"] = dict_conso dictValeurs["tracks_previsions"] = tracks_previsions dictValeurs["liste_IDconso"] = liste_IDconso # Lecture des tarifs du contrat req = """SELECT IDcontrat_tarif, date_debut, revenu, quotient, taux, tarif_base, tarif_depassement FROM contrats_tarifs WHERE IDcontrat=%d ;""" % self.IDcontrat DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() tracks_tarifs = [] liste_IDtarif = [] for IDcontrat_tarif, date_debut, revenu, quotient, taux, tarif_base, tarif_depassement in listeDonnees: date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) dictTarif = { "IDcontrat_tarif": IDcontrat_tarif, "date_debut": date_debut, "revenu": revenu, "quotient": quotient, "taux": taux, "tarif_base": tarif_base, "tarif_depassement": tarif_depassement, } tracks_tarifs.append(Track_tarif(dictTarif)) liste_IDtarif.append(IDcontrat_tarif) dictValeurs["tracks_tarifs"] = tracks_tarifs dictValeurs["liste_IDtarif"] = liste_IDtarif # Lecture des mensualités req = """SELECT IDprestation, date, label, montant_initial, prestations.montant, prestations.IDfacture, temps_facture, forfait_date_debut, forfait_date_fin, factures.numero FROM prestations LEFT JOIN factures ON factures.IDfacture = prestations.IDfacture WHERE IDcontrat=%d ;""" % self.IDcontrat DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() liste_prestations = [] liste_IDprestation = [] for IDprestation, date_facturation, label, montant_initial, montant, IDfacture, temps_facture, forfait_date_debut, forfait_date_fin, num_facture in listeDonnees: date_facturation = UTILS_Dates.DateEngEnDateDD(date_facturation) forfait_date_debut = UTILS_Dates.DateEngEnDateDD( forfait_date_debut) forfait_date_fin = UTILS_Dates.DateEngEnDateDD(forfait_date_fin) montant_initial = FloatToDecimal(montant_initial) montant = FloatToDecimal(montant) temps_facture = UTILS_Dates.HeureStrEnDelta(temps_facture) dictMensualite = { "IDprestation": IDprestation, "date_facturation": date_facturation, "label": label, "montant_initial": montant_initial, "montant": montant, "IDfacture": IDfacture, "temps_facture": temps_facture, "forfait_date_debut": forfait_date_debut, "forfait_date_fin": forfait_date_fin, "num_facture": num_facture, } liste_prestations.append(dictMensualite) liste_IDprestation.append(IDprestation) dictValeurs["liste_prestations"] = liste_prestations dictValeurs["liste_IDprestation"] = liste_IDprestation # Fermeture de la base if DBtemp == None: DB.Close() # Mémorisation des données self.SetValeurs(dictValeurs)
def __init__(self, parent, index=None, item=None): self.parent = parent self.index = index self.nom = item[0] self.categories = UTILS_Texte.ConvertStrToListe(item[1]) self.MAJ()
def GetPropositionsLocations(dictFiltresSelection={}, dictDemandeSelection=None, uniquement_disponibles=True): DB = GestionDB.DB() # Importation des questionnaires des produits req = """SELECT IDreponse, IDquestion, reponse, IDdonnee FROM questionnaire_reponses WHERE type='produit';""" DB.ExecuterReq(req) listeReponses = DB.ResultatReq() dictReponses = {} for IDreponse, IDquestion, reponse, IDproduit in listeReponses: dictTemp = { "IDreponse": IDreponse, "IDquestion": IDquestion, "reponse": reponse } if dictReponses.has_key(IDproduit) == False: dictReponses[IDproduit] = [] dictReponses[IDproduit].append(dictTemp) # Recherche les produits non disponibles dictLocations = GetProduitsLoues(DB=DB) # Importation des produits req = """SELECT IDproduit, IDcategorie, nom, quantite FROM produits;""" DB.ExecuterReq(req) listeProduitsTemp = DB.ResultatReq() listeProduits = [] dictProduits = {} dictProduitsByCategories = {} for IDproduit, IDcategorie, nom, quantite in listeProduitsTemp: if quantite == None: quantite = 1 # Recherche les réponses au questionnaire du produit if dictReponses.has_key(IDproduit): reponses = dictReponses[IDproduit] else: reponses = [] # Recherche les locations en cours du produit if dictLocations.has_key(IDproduit): disponible = quantite for dictLocation in dictLocations[IDproduit]: disponible -= dictLocation["quantite"] else: disponible = quantite if uniquement_disponibles == False or disponible > 0: dictTemp = { "IDproduit": IDproduit, "IDcategorie": IDcategorie, "disponible": disponible, "nom": nom, "reponses": reponses } listeProduits.append(dictTemp) dictProduits[IDproduit] = dictTemp if dictProduitsByCategories.has_key(IDcategorie) == False: dictProduitsByCategories[IDcategorie] = [] dictProduitsByCategories[IDcategorie].append(dictTemp) # Recherche les filtres de questionnaires req = """SELECT IDfiltre, questionnaire_filtres.IDquestion, choix, criteres, IDdonnee, questionnaire_categories.type, controle FROM questionnaire_filtres LEFT JOIN questionnaire_questions ON questionnaire_questions.IDquestion = questionnaire_filtres.IDquestion LEFT JOIN questionnaire_categories ON questionnaire_categories.IDcategorie = questionnaire_questions.IDcategorie WHERE categorie='location_demande';""" DB.ExecuterReq(req) listeFiltres = DB.ResultatReq() dictFiltres = {} for IDfiltre, IDquestion, choix, criteres, IDdemande, type, controle in listeFiltres: if dictFiltres.has_key(IDdemande) == False: dictFiltres[IDdemande] = [] dictFiltres[IDdemande].append({ "IDfiltre": IDfiltre, "IDquestion": IDquestion, "choix": choix, "criteres": criteres, "type": type, "controle": controle }) # Ajoute ou remplace avec le dictDemandeSelection if dictFiltresSelection != None: for IDdemande, listeFiltres in dictFiltresSelection.iteritems(): dictFiltres[IDdemande] = listeFiltres # Importation des demandes de locations # if dictDemande == None : # req = """SELECT IDdemande, date, IDfamille, categories, produits # FROM locations_demandes # WHERE statut='attente' # ORDER BY IDdemande;""" # DB.ExecuterReq(req) # listeDemandes = DB.ResultatReq() # else : # listeDemandes = [dictDemande,] req = """SELECT IDdemande, date, IDfamille, categories, produits FROM locations_demandes WHERE statut='attente' ORDER BY IDdemande;""" DB.ExecuterReq(req) listeDemandes = DB.ResultatReq() if dictDemandeSelection != None and dictDemandeSelection[ "IDdemande"] == None: listeDemandes.append(dictDemandeSelection) DB.Close() # Parcours les demandes dictControles = UTILS_Filtres_questionnaires.GetDictControles() dictPropositions = {} dictPositions = {} for demande in listeDemandes: # Met les données dans un dict if not isinstance(demande, dict): categories = UTILS_Texte.ConvertStrToListe(demande[3], siVide=[]) produits = UTILS_Texte.ConvertStrToListe(demande[4], siVide=[]) dictDemandeTemp = { "IDdemande": demande[0], "date": demande[1], "IDfamille": demande[2], "categories": categories, "produits": produits } else: dictDemandeTemp = demande if dictDemandeSelection != None and dictDemandeSelection[ "IDdemande"] == dictDemandeTemp["IDdemande"]: dictDemandeTemp = dictDemandeSelection IDdemande = dictDemandeTemp["IDdemande"] # Pré-sélection des produits à étudier listeProduitsTemp = [] if dictDemandeTemp["categories"] != []: for IDcategorie in dictDemandeTemp["categories"]: if dictProduitsByCategories.has_key(IDcategorie): listeProduitsTemp.extend( dictProduitsByCategories[IDcategorie]) if dictDemandeTemp["produits"] != []: for IDproduit in dictDemandeTemp["produits"]: dictProduit = dictProduits[IDproduit] if dictProduits.has_key( IDproduit) and dictProduit not in listeProduitsTemp: if dictDemandeTemp["categories"] == [] or dictProduit[ "IDcategorie"] in dictDemandeTemp["categories"]: listeProduitsTemp.append(dictProduit) if len(listeProduitsTemp) == 0: listeProduitsTemp = listeProduits # Parcours les produits for dictProduit in listeProduitsTemp: valide = True # # Vérifie si le produit est dans la liste des catégories souhaitées # if valide == True and dictDemandeTemp["categories"] != [] and dictProduit["IDcategorie"] not in dictDemandeTemp["categories"] : # valide = False # # # Vérifie si le produit est dans la liste des produits souhaités # if valide == True and dictDemandeTemp["produits"] != [] and dictProduit["IDproduit"] not in dictDemandeTemp["produits"] : # valide = False # Vérifie si le produit répond aux filtres de la demande if valide == True and dictFiltres.has_key(IDdemande): for dictFiltre in dictFiltres[IDdemande]: for dictReponse in dictProduit["reponses"]: resultat = UTILS_Filtres_questionnaires.Filtre( controle=dictFiltre["controle"], choix=dictFiltre["choix"], criteres=dictFiltre["criteres"], reponse=dictReponse["reponse"], dictControles=dictControles) if resultat == False: valide = False # Mémorisation de la proposition if valide == True: # Position dans la liste du produit if dictPositions.has_key(dictProduit["IDproduit"]) == False: dictPositions[dictProduit["IDproduit"]] = 0 dictPositions[dictProduit["IDproduit"]] += 1 position = dictPositions[dictProduit["IDproduit"]] # Proposition dictProduit = dict(dictProduit) if dictPropositions.has_key(IDdemande) == False: dictPropositions[IDdemande] = [] dictProduit["position"] = position dictPropositions[IDdemande].append(dictProduit) return dictPropositions
def __init__(self, listview=None, donnees=None): self.IDdemande = donnees[0] self.date = donnees[1] self.IDfamille = donnees[2] self.observations = donnees[3] # Catégories self.categories = UTILS_Texte.ConvertStrToListe(donnees[4], siVide=[]) liste_labels = [] for IDcategorie in self.categories : if IDcategorie in listview.dictCategories : liste_labels.append(listview.dictCategories[IDcategorie]) self.texte_categories = ", ".join(liste_labels) # Produits self.produits = UTILS_Texte.ConvertStrToListe(donnees[5], siVide=[]) liste_labels = [] for IDproduit in self.produits : if IDproduit in listview.dictProduits : liste_labels.append(listview.dictProduits[IDproduit]) self.texte_produits = ", ".join(liste_labels) # Statut self.statut = donnees[6] # Position self.position = None # Vérifie s'il y a des propositions de produits if self.statut == "refusee" : self.texte_statut = _(u"Refusée") elif self.statut == "attribuee" : self.texte_statut = _(u"Demande satisfaite") elif self.statut == "attente" : if self.IDdemande in listview.dictPropositions : # Recherche disponibilités listeProduitsProposes = listview.dictPropositions[self.IDdemande] if len(listeProduitsProposes) == 0 : self.texte_statut = _(u"En attente") elif len(listeProduitsProposes) == 1 : self.texte_statut = _(u"1 produit disponible") else : self.texte_statut = _(u"%d produits disponibles") % len(listeProduitsProposes) self.statut = "disponibilite" # Recherche meilleure position self.position = UTILS_Locations.GetMeilleurePosition(dictPropositions=listview.dictPropositions, IDdemande=self.IDdemande) else : self.texte_statut = _(u"En attente") # Formatage date if isinstance(self.date, str) or isinstance(self.date, six.text_type) : self.date = datetime.datetime.strptime(self.date, "%Y-%m-%d %H:%M:%S") # Récupération des réponses des questionnaires for dictQuestion in listview.liste_questions : setattr(self, "question_%d" % dictQuestion["IDquestion"], listview.GetReponse(dictQuestion["IDquestion"], self.IDdemande)) # Famille if listview.IDfamille == None : self.nomTitulaires = listview.dict_titulaires[self.IDfamille]["titulairesSansCivilite"] self.rue = listview.dict_titulaires[self.IDfamille]["adresse"]["rue"] self.cp = listview.dict_titulaires[self.IDfamille]["adresse"]["cp"] self.ville = listview.dict_titulaires[self.IDfamille]["adresse"]["ville"]
def GetHTML(self, IDactivite=None): if IDactivite == None: return "" DB = GestionDB.DB() # Importation des infos sur l'activité req = """SELECT nom, date_debut, date_fin FROM activites WHERE IDactivite=%d ;""" % IDactivite DB.ExecuterReq(req) listeInfos = DB.ResultatReq() if len(listeInfos) == 0: return "" activite_nom, activite_date_debut, activite_date_fin = listeInfos[0] # Importation des tarifs req = """SELECT IDtarif, categories_tarifs, date_debut, date_fin, methode, noms_tarifs.IDnom_tarif, noms_tarifs.nom FROM tarifs LEFT JOIN noms_tarifs ON noms_tarifs.IDnom_tarif = tarifs.IDnom_tarif WHERE tarifs.IDactivite=%d ORDER BY date_debut DESC;""" % IDactivite DB.ExecuterReq(req) listeTarifs = DB.ResultatReq() req = """SELECT IDcategorie_tarif, nom FROM categories_tarifs WHERE IDactivite=%d;""" % IDactivite DB.ExecuterReq(req) listeCategories = DB.ResultatReq() dictCategories = {} for IDcategorie_tarif, nom in listeCategories: dictCategories[IDcategorie_tarif] = nom # Importation des lignes de tarif champsTable = ", ".join(CHAMPS_TABLE_LIGNES) req = """SELECT %s FROM tarifs_lignes WHERE IDactivite=%d ORDER BY num_ligne;""" % (champsTable, IDactivite) DB.ExecuterReq(req) listeLignes = DB.ResultatReq() DB.Close() source = [] source.append(u"<FONT SIZE=+1><B>%s</B></FONT>" % activite_nom) source.append(u"<HR WIDTH='100%'>") if len(listeTarifs) == 0: source.append(u"<P>Aucun tarif</P>") for IDtarif, categories_tarifs, date_debut, date_fin, methode, IDnom_tarif, nom_prestation in listeTarifs: listeCategories = UTILS_Texte.ConvertStrToListe(categories_tarifs) liste_temp = [] for IDcategorie_tarif in listeCategories: liste_temp.append(dictCategories[IDcategorie_tarif]) texte_categories = u", ".join(liste_temp) if True: #IDtarif in liste_tarifs_valides : # Création des champs index = 0 for dictMethode in LISTE_METHODES: if dictMethode["code"] == methode: champs = dictMethode["champs"] index += 1 tableau = [] ligne = [] dict_remplissage_colonnes = {} numColonne = 0 for code in champs: for dict_colonne in LISTE_COLONNES: if dict_colonne["code"] == code: ligne.append(dict_colonne["label"]) dict_remplissage_colonnes[numColonne] = 0 numColonne += 1 tableau.append(ligne) numLigne = 0 for valeurs in listeLignes: IDtarif_ligne = valeurs[2] code = valeurs[3] ligne = [] if IDtarif == IDtarif_ligne: dictValeurs = {} # Récupération des valeurs de la base indexValeur = 0 for valeur in valeurs: if valeur == "None": valeur = None dictValeurs[ CHAMPS_TABLE_LIGNES[indexValeur]] = valeur indexValeur += 1 # Remplissage de la ligne numColonne = 0 for codeChamp in champs: valeur = dictValeurs[codeChamp] if type(valeur) == int or type(valeur) == float: if codeChamp in ("montant_unique", "montant_min", "montant_max", "ajustement", "revenu_min", "revenu_max"): valeur = u"%.2f %s" % (valeur, SYMBOLE) else: valeur = str(valeur) if valeur == "None": valeur = "" if codeChamp == "date" and valeur != None: valeur = UTILS_Dates.DateEngFr(valeur) if valeur == None: valeur = "" ligne.append(valeur) if valeur != "": dict_remplissage_colonnes[numColonne] += 1 numColonne += 1 tableau.append(ligne) numLigne += 1 # Enlève des colonnes vides numColonne = 0 tableau2 = [] for ligne in tableau: ligne2 = [] numColonne = 0 for valeur in ligne: if dict_remplissage_colonnes[numColonne] > 0: ligne2.append(valeur) numColonne += 1 tableau2.append(ligne2) #print (nom_prestation, date_debut, date_fin) #for ligne in tableau2 : # print " ", ligne source.append( u"<P><B>%s</B><BR><FONT SIZE=-2>%s - Tarif à partir du %s</FONT></P>" % (nom_prestation, texte_categories, UTILS_Dates.DateEngFr(date_debut))) source.append(u"<P><TABLE BORDER CELLSPACING=1 BORDER=0>") for ligne in tableau2: source.append(u"<TR ALIGN=CENTER>") for valeur in ligne: source.append(u"<TD>%s</TD>" % valeur) source.append(u"</TR>") source.append(u"</TABLE></P>") return "\n".join(source)
def OnBoutonOk(self, event): # Date et heure de la demande date_demande = self.ctrl_date_demande.GetDate() if date_demande == None: dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement saisir une date pour cette demande !" ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_date_demande.SetFocus() return heure_demande = self.ctrl_heure_demande.GetHeure() if heure_demande == None or self.ctrl_heure_demande.Validation( ) == False: dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement saisir une heure pour cette demande !" ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_heure_demande.SetFocus() return date_demande = datetime.datetime(year=date_demande.year, month=date_demande.month, day=date_demande.day, hour=int(heure_demande[:2]), minute=int(heure_demande[3:])) # Loueur IDfamille = self.ctrl_loueur.GetIDfamille() if IDfamille == None: dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement sélectionner un loueur pour cette demande !" ), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return # Observations observations = self.ctrl_observations.GetValue() # Critères categories = UTILS_Texte.ConvertListeToStr( self.notebook.GetPage( "criteres").ctrl_categories.GetListeCategories()) produits = UTILS_Texte.ConvertListeToStr( self.notebook.GetPage("criteres").ctrl_produits.GetListeProduits()) # Statut statut = self.ctrl_statut.GetCodePageActive() motif_refus = self.ctrl_statut.GetPageByCode( "refusee").ctrl_motif.GetValue() IDlocation = self.ctrl_attribution.GetIDlocation( ) # self.ctrl_statut.GetPageByCode("attribuee").GetIDlocation() if IDlocation != None: statut = "attribuee" # Sauvegarde DB = GestionDB.DB() listeDonnees = [ ("date", date_demande), ("IDfamille", IDfamille), ("observations", observations), ("categories", categories), ("produits", produits), ("statut", statut), ("motif_refus", motif_refus), ("IDlocation", IDlocation), ] if self.IDdemande == None: self.IDdemande = DB.ReqInsert("locations_demandes", listeDonnees) else: DB.ReqMAJ("locations_demandes", listeDonnees, "IDdemande", self.IDdemande) # Sauvegarde des filtres listeID = [] for dictFiltre in self.notebook.GetPage( "criteres").ctrl_filtres.GetDonnees(): listeID.append(dictFiltre["IDfiltre"]) listeDonnees = [ ("IDquestion", dictFiltre["IDquestion"]), ("categorie", "location_demande"), ("choix", dictFiltre["choix"]), ("criteres", dictFiltre["criteres"]), ("IDdonnee", self.IDdemande), ] # Sauvegarde dans DB if dictFiltre["IDfiltre"] == None: IDfiltre = DB.ReqInsert("questionnaire_filtres", listeDonnees) else: DB.ReqMAJ("questionnaire_filtres", listeDonnees, "IDfiltre", dictFiltre["IDfiltre"]) for dictInitialFiltre in self.listeInitialeFiltres: if dictInitialFiltre["IDfiltre"] not in listeID: DB.ReqDEL("questionnaire_filtres", "IDfiltre", dictInitialFiltre["IDfiltre"]) # Sauvegarde du questionnaire self.notebook.GetPage("questionnaire").ctrl_questionnaire.Sauvegarde( DB=DB, IDdonnee=self.IDdemande) # Fermeture de la base DB.Close() # Fermeture de la fenêtre self.EndModal(wx.ID_OK)
def Importation(self): """ Importation des données """ if self.IDdemande != None: DB = GestionDB.DB() req = """SELECT date, IDfamille, observations, categories, produits, statut, motif_refus, IDlocation FROM locations_demandes WHERE IDdemande=%d;""" % self.IDdemande DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() date, IDfamille, observations, categories, produits, statut, motif_refus, IDlocation = listeDonnees[ 0] req = """SELECT IDfiltre, IDquestion, categorie, choix, criteres FROM questionnaire_filtres WHERE categorie='location_demande' AND IDdonnee=%d;""" % self.IDdemande DB.ExecuterReq(req) listeFiltres = DB.ResultatReq() DB.Close() else: date = None IDfamille = None observations = "" categories = "" produits = "" statut = "attente" motif_refus = "" IDlocation = None listeFiltres = [] # Généralités if date != None: self.ctrl_date_demande.SetDate( datetime.datetime.strftime(UTILS_Dates.DateEngEnDateDDT(date), "%Y-%m-%d")) self.ctrl_heure_demande.SetHeure( datetime.datetime.strftime(UTILS_Dates.DateEngEnDateDDT(date), "%H:%M")) if IDfamille != None: self.ctrl_loueur.SetIDfamille(IDfamille) if observations != None: self.ctrl_observations.SetValue(observations) # Critères self.notebook.GetPage("criteres").ctrl_categories.SetListeCategories( UTILS_Texte.ConvertStrToListe(categories)) self.notebook.GetPage("criteres").ctrl_produits.SetListeProduits( UTILS_Texte.ConvertStrToListe(produits)) # Filtres listeDonnees = [] for IDfiltre, IDquestion, categorie, choix, criteres in listeFiltres: listeDonnees.append({ "IDfiltre": IDfiltre, "IDquestion": IDquestion, "choix": choix, "criteres": criteres }) self.notebook.GetPage("criteres").ctrl_filtres.SetDonnees(listeDonnees) self.listeInitialeFiltres = copy.deepcopy(listeDonnees) # Statut self.ctrl_statut.SetPageByCode(statut) if motif_refus != None: self.ctrl_statut.GetPageByCode("refusee").ctrl_motif.SetValue( motif_refus) self.ctrl_statut.Show(True) self.ctrl_attribution.Show(False) if IDlocation != None: #self.ctrl_statut.GetPageByCode("attribuee").SetIDlocation(IDlocation) #self.ctrl_statut.GetChoiceCtrl().Enable(False) self.SetAttribution(IDlocation)
def SetCategories(self, categories_tarifs): if categories_tarifs != None : listeCategories = UTILS_Texte.ConvertStrToListe(categories_tarifs) self.ctrl_categories.SetIDcoches(listeCategories)
def Sauvegarde(self): # Nom nom = self.ctrl_nom.GetValue() if nom == "": dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement saisir un nom !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False abrege = self.ctrl_abrege.GetValue() if abrege == "": dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement saisir un nom abrégé !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False seuil_alerte = int(self.ctrl_seuil.GetValue()) heure_min = self.ctrl_heure_min.GetHeure() if heure_min != None and self.ctrl_heure_min.Validation() == False: dlg = wx.MessageDialog( self, _(u"L'heure minimale semble être incorrecte !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_heure_min.SetFocus() return False heure_max = self.ctrl_heure_max.GetHeure() if heure_max != None and self.ctrl_heure_max.Validation() == False: dlg = wx.MessageDialog( self, _(u"L'heure maximale semble être incorrecte !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_heure_max.SetFocus() return False if (heure_min != None and heure_max == None) or (heure_min == None and heure_max != None): dlg = wx.MessageDialog(self, _(u"La plage horaire est incomplète !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_heure_min.SetFocus() return False # Affichage afficher_page_accueil = int( self.check_afficher_page_accueil.GetValue()) afficher_grille_conso = int( self.check_afficher_grille_conso.GetValue()) # Validité if self.radio_illimitee.GetValue() == True: date_debut = "1977-01-01" date_fin = "2999-01-01" else: date_debut = self.ctrl_date_debut.GetDate() if date_debut == None: dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement saisir une date de début de validité !" ), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False date_fin = self.ctrl_date_fin.GetDate() if date_fin == None: dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement saisir une date de fin de validité !" ), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False # Etiquettes etiquettes = UTILS_Texte.ConvertListeToStr( self.ctrl_etiquettes.GetCoches()) # Enregistrement DB = GestionDB.DB() listeDonnees = [ ("IDactivite", self.IDactivite), ("nom", nom), ("abrege", abrege), ("seuil_alerte", seuil_alerte), ("date_debut", date_debut), ("date_fin", date_fin), ("heure_min", heure_min), ("heure_max", heure_max), ("afficher_page_accueil", afficher_page_accueil), ("afficher_grille_conso", afficher_grille_conso), ("etiquettes", etiquettes), ] if self.IDunite_remplissage == None: # Recherche le numéro d'ordre req = """SELECT IDunite_remplissage, ordre FROM unites_remplissage WHERE IDactivite=%d ORDER BY ordre DESC LIMIT 1 ;""" % self.IDactivite DB.ExecuterReq(req) listeTemp = DB.ResultatReq() if len(listeTemp) == 0: ordre = 1 else: ordre = listeTemp[0][1] + 1 listeDonnees.append(("ordre", ordre)) self.IDunite_remplissage = DB.ReqInsert("unites_remplissage", listeDonnees) self.ctrl_unites.IDunite_remplissage = self.IDunite_remplissage else: DB.ReqMAJ("unites_remplissage", listeDonnees, "IDunite_remplissage", self.IDunite_remplissage) # Incompatibilités self.ctrl_unites.Sauvegarde() DB.Close() return True
def GetDonneesImpression(self, listeDemandes=[]): """ Impression des locations """ dlgAttente = wx.BusyInfo(_(u"Recherche des données..."), None) # Récupère les données de la facture if len(listeDemandes) == 0: conditions = "()" elif len(listeDemandes) == 1: conditions = "(%d)" % listeDemandes[0] else: conditions = str(tuple(listeDemandes)) DB = GestionDB.DB() # Importation des catégories de produits req = """SELECT IDcategorie, nom FROM produits_categories;""" DB.ExecuterReq(req) listeCategories = DB.ResultatReq() self.dictCategories = {} for IDcategorie, nom in listeCategories : self.dictCategories[IDcategorie] = nom # Importation des produits req = """SELECT IDproduit, nom FROM produits;""" DB.ExecuterReq(req) listeProduits = DB.ResultatReq() self.dictProduits = {} for IDproduit, nom in listeProduits : self.dictProduits[IDproduit] = nom # # Importation des critères # req = """SELECT IDfiltre, IDquestion, categorie, choix, criteres FROM questionnaire_filtres WHERE categorie='location_demande' AND IDdonnee IN %s;""" % conditions # DB.ExecuterReq(req) # listeFiltres = DB.ResultatReq() # # req = """SELECT IDquestion, label, controle # FROM questionnaire_questions;""" # DB.ExecuterReq(req) # listeQuestions = DB.ResultatReq() # DICT_QUESTIONS = {} # for IDquestion, label, controle in listeQuestions: # DICT_QUESTIONS[IDquestion] = {"label": label, "controle": controle} # # # Importation des choix # req = """SELECT IDchoix, IDquestion, label # FROM questionnaire_choix # ORDER BY ordre;""" # DB.ExecuterReq(req) # listeChoix = DB.ResultatReq() # DICT_CHOIX = {} # for IDchoix, IDquestion, label in listeChoix: # DICT_CHOIX[IDchoix] = {"label": label, "IDquestion": IDquestion, } # Recherche les locations req = """SELECT IDdemande, date, IDfamille, observations, categories, produits, statut, motif_refus, IDlocation FROM locations_demandes WHERE IDdemande IN %s;""" % conditions DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() if len(listeDonnees) == 0: del dlgAttente return False dictDonnees = {} dictChampsFusion = {} for item in listeDonnees: IDdemande = item[0] date = item[1] IDfamille = item[2] observations = item[3] categories = item[4] produits = item[5] statut = item[6] motif_refus = item[7] IDlocation = item[8] # Date de la demande if isinstance(date, str) or isinstance(date, six.text_type): date = datetime.datetime.strptime(date, "%Y-%m-%d %H:%M:%S") date_texte = datetime.datetime.strftime(date, "%d/%m/%Y") heure_texte = datetime.datetime.strftime(date, "%Hh%M") # Catégories categories = UTILS_Texte.ConvertStrToListe(categories, siVide=[]) liste_labels = [] for IDcategorie in categories: if IDcategorie in self.dictCategories: liste_labels.append(self.dictCategories[IDcategorie]) texte_categories = ", ".join(liste_labels) # Produits produits = UTILS_Texte.ConvertStrToListe(produits, siVide=[]) liste_labels = [] for IDproduit in produits: if IDproduit in self.dictProduits: liste_labels.append(self.dictProduits[IDproduit]) texte_produits = ", ".join(liste_labels) # if IDindividu != None and self.dictIndividus.has_key(IDindividu): # beneficiaires = self.dictIndividus[IDindividu]["nom_complet"] # rue = self.dictIndividus[IDindividu]["rue"] # cp = self.dictIndividus[IDindividu]["cp"] # ville = self.dictIndividus[IDindividu]["ville"] # Famille if IDfamille != None: nomTitulaires = self.dictTitulaires[IDfamille]["titulairesAvecCivilite"] famille_rue = self.dictTitulaires[IDfamille]["adresse"]["rue"] famille_cp = self.dictTitulaires[IDfamille]["adresse"]["cp"] famille_ville = self.dictTitulaires[IDfamille]["adresse"]["ville"] else: nomTitulaires = "Famille inconnue" famille_rue = "" famille_cp = "" famille_ville = "" # Mémorisation des données dictDonnee = { "select": True, "{IDDEMANDE}": str(IDdemande), "{DATE}": date_texte, "{HEURE}": heure_texte, "{CATEGORIES}": texte_categories, "{PRODUITS}": texte_produits, "{NOTES}": observations, "{ORGANISATEUR_NOM}": self.dictOrganisme["nom"], "{ORGANISATEUR_RUE}": self.dictOrganisme["rue"], "{ORGANISATEUR_CP}": self.dictOrganisme["cp"], "{ORGANISATEUR_VILLE}": self.dictOrganisme["ville"], "{ORGANISATEUR_TEL}": self.dictOrganisme["tel"], "{ORGANISATEUR_FAX}": self.dictOrganisme["fax"], "{ORGANISATEUR_MAIL}": self.dictOrganisme["mail"], "{ORGANISATEUR_SITE}": self.dictOrganisme["site"], "{ORGANISATEUR_AGREMENT}": self.dictOrganisme["num_agrement"], "{ORGANISATEUR_SIRET}": self.dictOrganisme["num_siret"], "{ORGANISATEUR_APE}": self.dictOrganisme["code_ape"], "{DATE_EDITION_COURT}": UTILS_Dates.DateDDEnFr(datetime.date.today()), "{DATE_EDITION_LONG}": UTILS_Dates.DateComplete(datetime.date.today()), } # Ajoute les informations de base individus et familles # if IDindividu != None: # dictDonnee.update(self.infosIndividus.GetDictValeurs(mode="individu", ID=IDindividu, formatChamp=True)) if IDfamille != None: dictDonnee.update(self.infosIndividus.GetDictValeurs(mode="famille", ID=IDfamille, formatChamp=True)) # Ajoute les réponses des questionnaires for dictReponse in self.Questionnaires_familles.GetDonnees(IDfamille): dictDonnee[dictReponse["champ"]] = dictReponse["reponse"] if dictReponse["controle"] == "codebarres": dictDonnee["{CODEBARRES_QUESTION_%d}" % dictReponse["IDquestion"]] = dictReponse["reponse"] for dictReponse in self.Questionnaires_demandes.GetDonnees(IDdemande): dictDonnee[dictReponse["champ"]] = dictReponse["reponse"] if dictReponse["controle"] == "codebarres": dictDonnee["{CODEBARRES_QUESTION_%d}" % dictReponse["IDquestion"]] = dictReponse["reponse"] dictDonnees[IDdemande] = dictDonnee # Champs de fusion pour Email dictChampsFusion[IDdemande] = {} for key, valeur in dictDonnee.items(): if key[0] == "{": dictChampsFusion[IDdemande][key] = valeur del dlgAttente return dictDonnees, dictChampsFusion
def OnBoutonTraiter(self, event=None): self.parent.EcritLog(_(u"Application de la demande de locations"), self.ctrl_log) resultats = { "ajouter": { True: 0, False: 0 }, "modifier": { True: 0, False: 0 }, "supprimer": { True: 0, False: 0 } } DB = GestionDB.DB() for track in self.ctrl_locations.donnees: listeDonnees = [ ("IDfamille", self.track.IDfamille), ("IDproduit", track.IDproduit), ("date_debut", track.date_debut), ("date_fin", track.date_fin), ("quantite", track.quantite), ] if track.resultat != "ok": if track.etat == "ajouter": if track.action_possible == True: listeDonnees.append( ("date_saisie", datetime.date.today())) listeDonnees.append( ("IDlocation_portail", track.IDlocation)) IDlocation = DB.ReqInsert("locations", listeDonnees) resultat = _(u"Ajout de %s du %s") % ( track.nom_produit, track.date_debut_txt) DB.ReqMAJ("portail_reservations_locations", [("resultat", "ok")], "IDreservation", track.IDreservation) else: resultat = _(u"%s du %s : %s") % (track.nom_produit, track.date_debut_txt, track.statut) self.parent.EcritLog(resultat, self.ctrl_log) if track.etat == "modifier": if track.action_possible == True: if "-" in track.IDlocation: DB.ReqMAJ("locations", listeDonnees, "IDlocation_portail", track.IDlocation, IDestChaine=True) else: DB.ReqMAJ("locations", listeDonnees, "IDlocation", int(track.IDlocation)) resultat = _(u"Modification de %s du %s") % ( track.nom_produit, track.date_debut_txt) DB.ReqMAJ("portail_reservations_locations", [("resultat", "ok")], "IDreservation", track.IDreservation) else: resultat = _(u"%s du %s : %s") % (track.nom_produit, track.date_debut_txt, track.statut) self.parent.EcritLog(resultat, self.ctrl_log) if track.etat == "supprimer": if track.action_possible == True: if "-" in track.IDlocation: DB.ReqDEL("locations", "IDlocation_portail", track.IDlocation, IDestChaine=True) else: DB.ReqDEL("locations", "IDlocation", int(track.IDlocation)) resultat = _(u"Suppression de %s du %s") % ( track.nom_produit, track.date_debut_txt) DB.ReqMAJ("portail_reservations_locations", [("resultat", "ok")], "IDreservation", track.IDreservation) else: resultat = _(u"%s du %s : %s") % (track.nom_produit, track.date_debut_txt, track.statut) self.parent.EcritLog(resultat, self.ctrl_log) # Mémorisation pour réponse resultats[track.etat][track.action_possible] += 1 DB.Close() # Formatage de la réponse liste_resultats = [] for etat, valeurs in resultats.items(): for succes, quantite in valeurs.items(): if quantite: if succes == True: txt_validation = u"validé" else: txt_validation = u"refusé" if quantite == 1: pluriel = "" else: pluriel = "s" if etat == "ajouter": liste_resultats.append( u"%d ajout%s %s%s" % (quantite, pluriel, txt_validation, pluriel)) if etat == "modifier": liste_resultats.append( u"%d modification%s %se%s" % (quantite, pluriel, txt_validation, pluriel)) if etat == "supprimer": liste_resultats.append( u"%d suppression%s %se%s" % (quantite, pluriel, txt_validation, pluriel)) if liste_resultats: self.reponse = UTILS_Texte.ConvertListeToPhrase( liste_resultats) + "." self.parent.EcritLog( _(u"Réponse : %s") % self.reponse, self.ctrl_log) # MAJ de la liste des actions self.ctrl_locations.MAJ(track_demande=self.track)