Stage au Département des Sciences Géomatiques de l'Université Laval et au Centre de Recherche en Données et Intelligence Géospatiales (CRDIG)

				
					"""

Ce script utilise ArcPy pour peupler les tables et les relations d'une géodatabase d'entreprise (EGDB) en utilisant les données exportées d'un formulaire Survey123. Il couvre plusieurs étapes de manipulation et d'insertion de données, ainsi que la gestion des relations entre différentes tables. Voici les grandes étapes du script :

1. Initialisation des Variables : Définition des chemins pour les géodatabases, les couches et les tables source et cible, ainsi que les couches temporaires pour les manipulations.
2. Insertion des Données dans la Table Groupe : Recherche de l'ID maximum actuel dans la table `groupe`, insertion des données du formulaire Survey123 filtrées par groupe, et ajout des nouveaux groupes avec des ID uniques.
3. Insertion des Données dans la Table Parcours : Recherche de l'ID maximum actuel dans la table `parcours`, insertion des données du formulaire Survey123 filtrées par parcours, et ajout des nouveaux parcours avec des ID uniques.
4. Insertion des Données dans la Table Point d'Intérêt : Recherche de l'ID maximum actuel dans la table `point_interet`, insertion des données de la couche `repeat_poi`, ajout des informations des champs sensoriels, et gestion des relations intérieur/extérieur.
5. Insertion des Données dans la Table Photo : Recherche de l'ID maximum actuel dans la table `photo`, insertion des données des photos attachées depuis la couche `repeat_poi__ATTACH`, gestion des photos supplémentaires si nécessaire, et mise à jour des relations.
6. Peuplement des Tables de Relation : Ajout des ID générés dans les tables `Formulaire_1` et `repeat_poi`, création de jointures pour associer les ID aux relations entre les points d'intérêt, les groupes, et les parcours, et insertion des relations dans les tables correspondantes.
7. Peuplement de la Table de Relation poi_photo_groupe : Ajout des relations entre les photos et les groupes de points d'intérêt, en utilisant des jointures multiples pour assembler toutes les données nécessaires, et insertion des relations dans les tables cibles.
8. Exécution du Script : Appel de la fonction principale pour lancer tout le processus décrit ci-dessus.


-> À faire tourner avec le projet ArcGIS joint
"""


import arcpy
import arcpy.conversion
import arcpy.management

# Initialisation des variables à ajouter
p_fgdb = "E:/Avignon_Universite/L3/Semestre_2/Stage/DEAMBUL/projet_arcgis/export_donnes_enquete/f5594030-f86b-43a2-8ab9-6a4e16f252a8.gdb"           #Paramètre -> chemin de la fgdb exporté à l'étape 1. Penser à changer les p_jointure_1/ par des /
p_formulaire_1 = p_fgdb + "/Formulaire_1"
p_repeat_poi = p_fgdb + "/repeat_poi"
p_attach = p_fgdb + "/repeat_poi__ATTACH"

# Initialisation des variables de la EGDB
p_egdb = "E:/Avignon_Universite/L3/Semestre_2/Stage/DEAMBUL/projet_arcgis/deambul_dev.sde"  #Chemin de la EGDB                                      #Paramètre
p_groupe = p_egdb + "/deambul_dev.deambul_dev.groupe"                                       #tables parent
p_parcours = p_egdb + "/deambul_dev.deambul_dev.parcours"
p_point_interet = p_egdb + "/deambul_dev.deambul_dev.point_interet" 
p_photo = p_egdb + "/deambul_dev.deambul_dev.photo"

# Initialisation des variables pour les tables enfant
p_defaut_gdb = "E:/Avignon_Universite/L3/Semestre_2/Stage/DEAMBUL/projet_arcgis/Default.gdb" 
p_groupe_poi = p_egdb + "/deambul_dev.deambul_dev.groupe_poi"                               #tables enfant
p_parcours_poi = p_egdb + "/deambul_dev.deambul_dev.parcours_poi"
p_poi_photo_groupe = p_egdb + "/deambul_dev.deambul_dev.poi_photo_groupe"
p_poi_photo_parcours = p_egdb + "/deambul_dev.deambul_dev.poi_photo_parcours"

#Initialisation des variables/couches temporaires pour les manipulations (jointures, CopyRows, CopyFeatures)
p_jointure_1 = p_defaut_gdb + "/jointure_1" 
p_jointure_2 = p_defaut_gdb + "/jointure_2" 
p_jointure_3 = p_defaut_gdb + "/jointure_3" 
p_jointure_4 = p_defaut_gdb + "/jointure_4"
p_jointure_5 = p_defaut_gdb + "/jointure_5" 
p_groupe_poi_temp = "memory/tbl_tempo_groupe"
p_parcours_poi_temp = "memory/tbl_tempo_parcours"


id_poi = []
id_photo = []
id_groupe = []
id_parcours = []

def peuplement():

    arcpy.env.overwriteOutput = True

    #___________________________________________________________________________________#
    #                                                                                   #
    # ---------------    Insertion des donnees dans la table groupe     --------------- #
    #___________________________________________________________________________________#

    # Trouver la valeur maximale de idgroupe dans la table groupe
    max_idgroupe = 0
    with arcpy.da.SearchCursor(p_groupe, ["idgroupe"]) as cursor:
        for row in cursor:
            if row[0] is not None and row[0] > max_idgroupe:
                max_idgroupe = row[0]

    # Définir les champs source et cible pour la table des groupes
    sf_g_1 = ["titre_groupe",
              "description_groupe", 
              "contributeur_groupe", 
              "date_debut", 
              "date_fin", 
              "parcours_groupe"]
    
    tf_g_1 = ["nom",
               "description", 
               "contributeur", 
               "date_debut", 
               "date_fin"]

    # Clause WHERE pour filtrer les enregistrements où le champ 'parcours_groupe' est égal à 'Groupe'
    test_groupe = "parcours_groupe = 'groupe'"

    # Utiliser SearchCursor pour lire les données de la table source (Formulaire_1)
    with arcpy.da.SearchCursor(p_formulaire_1, sf_g_1, where_clause=test_groupe) as search_cursor:
        # Utiliser InsertCursor pour insérer les données dans la table cible (p_groupe)
        with arcpy.da.InsertCursor(p_groupe, ["idgroupe"] + tf_g_1) as insert_cursor:
            for row in search_cursor:
                target_row_g = []
                # Ajouter une nouvelle valeur unique pour idgroupe
                max_idgroupe += 1
                target_row_g.append(max_idgroupe)
                id_groupe.append(target_row_g)

                # Ajouter les valeurs des champs source aux champs cibles
                for src_field in sf_g_1[:-1]:  # Exclure 'parcours_groupe' lors de l'ajout des champs
                    target_row_g.append(row[sf_g_1.index(src_field)])
                # Insérer la ligne dans la table cible
                insert_cursor.insertRow(target_row_g)

    print(" -> Peuplement des groupes effectué")


    #___________________________________________________________________________________#
    #                                                                                   #
    # ---------------   Insertion des donnees dans la table parcours    --------------- #
    #___________________________________________________________________________________#

    # Trouver la valeur maximale de idparcours dans la table parcours
    max_idparcours = 0
    with arcpy.da.SearchCursor(p_parcours, ["idparcours"]) as cursor:
        for row in cursor:
            if row[0] is not None and row[0] > max_idparcours:
                max_idparcours = row[0]

    # Définition des champs source et cible pour la table des parcours
    sf_p_1 = ["titre_parcours", 
              "description_parcours",
               "contributeur_parcours", 
               "date_debut", 
               "date_fin"]
    
    tf_p_1 = ["titre", 
              "description", 
              "contributeur", 
              "date_debut", 
              "date_fin"]

    sf_p_2 = ["hiver", 
              "printemps", 
              "ete", 
              "automne"]
    tf_p_2 = ["hiver", 
              "printemps", 
              "ete", 
              "automne"]

    test_parcours = "parcours_groupe = 'parcours'"

    # Utiliser SearchCursor pour lire les données de la table source (Formulaire_1)
    with arcpy.da.SearchCursor(p_formulaire_1, sf_p_1, where_clause=test_parcours) as search_cursor:
        # Utiliser InsertCursor pour insérer les données dans la couche cible (p_parcours)
        with arcpy.da.InsertCursor(p_parcours, ["idparcours"] + tf_p_1 + tf_p_2) as insert_cursor:
            for row in search_cursor:
                # Initialiser une liste pour contenir les valeurs des champs de la couche cible
                target_row_p = []

                # Ajouter une nouvelle valeur unique pour idparcours
                max_idparcours += 1
                target_row_p.append(max_idparcours)
                id_parcours.append(target_row_p)

                # Ajouter les champs de sf_p_1 à tf_p_1
                for src_field in sf_p_1:
                    target_row_p.append(row[sf_p_1.index(src_field)])

                # Lire les valeurs des champs de la table p_repeat_poi pour sf_p_2
                with arcpy.da.SearchCursor(p_repeat_poi, sf_p_2) as search_cursor_2:
                    row_2 = next(search_cursor_2)
                    for src_field_2 in sf_p_2:
                        target_row_p.append(row_2[sf_p_2.index(src_field_2)])

                # Vérification du nombre d'éléments dans target_row_p
                if len(target_row_p) == len(["idparcours"] + tf_p_1 + tf_p_2):
                    # Insérer la ligne dans la couche cible
                    insert_cursor.insertRow(target_row_p)

    print(" -> Peuplement des parcours effectué")



    #___________________________________________________________________________________#
    #                                                                                   #
    # --------------- Insertion des donnees dans la table point_interet --------------- #
    #___________________________________________________________________________________#

    sf_pi_1 = [ "SHAPE@",
                "titre_poi",                # couche repeat_poi
                "description_generique",
                "description_poi_parcours",
                "auteur",
                "contributeur_poi",
                "date_photo_1",
                "url_1",
                "url_2",
                "url_3",
                "SHAPE@Y",
                "SHAPE@X",
                "odre_poi_parcours",
                "interieur_exterieur"]   
       
    tf_pi_1 = [ "SHAPE@",
                "titre",                    
                "description_1", 
                "description_2", 
                "auteur",
                "contributeur_poi",
                "an_creation", 
                "hyp_li1",
                "hyp_li2",
                "hyp_li3",
                "latitude",
                "longitude",
                "ordre",
                "interieur",
                "exterieur"]

    sf_pi_2 = [ "vue",                      # couche Formulaire_1
                "gout",
                "toucher",
                "odorat",
                "ouie"]       
                                     
    tf_pi_2 = [ "vue",
                "gout",
                "toucher",
                "odorat",
                "ouie"]
    
    # Trouver la valeur maximale de idpoi dans la table point_interet
    max_idpoi = 0
    with arcpy.da.SearchCursor(p_point_interet, ["idpoi"]) as cursor:
        for row in cursor:
            if row[0] is not None and row[0] > max_idpoi:
                max_idpoi = row[0]

    # Charger les données de p_formulaire_1 dans un dictionnaire
    data_formulaire_1 = {}
    with arcpy.da.SearchCursor(p_formulaire_1, sf_pi_2) as search_cursor_2:
        for row in search_cursor_2:
            key = row[0]  # Assurez-vous que cela correspond à la clé unique
            data_formulaire_1[key] = row


    # Utiliser SearchCursor pour lire les données de la classe d'entités source (sf_pi_1)
    with arcpy.da.SearchCursor(p_repeat_poi, sf_pi_1) as search_cursor_1:
        # Utiliser InsertCursor pour insérer les données dans la classe d'entités cible
        with arcpy.da.InsertCursor(p_point_interet, ["idpoi"] + tf_pi_1 + tf_pi_2) as insert_cursor:
            for row_1 in search_cursor_1:
                # Créer une nouvelle ligne pour la classe d'entités cible en respectant le mapping des champs
                target_row = []
                
                # Ajouter une nouvelle valeur unique pour idpoi
                max_idpoi += 1
                target_row.append(max_idpoi)
                id_poi.append(target_row)

                # Ajouter les champs de sf_pi_1 à tf_pi_1
                for src_field in sf_pi_1:
                    if src_field == "interieur_exterieur":
                        interieur = -1 if row_1[sf_pi_1.index(src_field)] == "Intérieur" else 0
                        exterieur = -1 if interieur == 0 else 0
                        target_row.append(interieur)
                        target_row.append(exterieur)
                    else:
                        target_row.append(row_1[sf_pi_1.index(src_field)])

                for src_field in sf_pi_2:
                    if src_field == "vue":
                        vue = 0 if row_1[sf_pi_2.index(src_field)]  is None else -1
                        target_row.append(vue)
                    if src_field == "gout":
                        vue = 0 if row_1[sf_pi_2.index(src_field)]  is None else -1
                        target_row.append(vue)
                    if src_field == "toucher":
                        vue = 0 if row_1[sf_pi_2.index(src_field)]  is None else -1
                        target_row.append(vue)
                    if src_field == "odorat":
                        vue = 0 if row_1[sf_pi_2.index(src_field)]  is None else -1
                        target_row.append(vue)
                    if src_field == "ouie":
                        vue = 0 if row_1[sf_pi_2.index(src_field)]  is None else -1
                        target_row.append(vue)
             
            
            # Insérer la ligne dans la classe d'entités cible
                insert_cursor.insertRow(target_row)

    print(" -> Peuplement des points d'intérêt effectué")    



    #___________________________________________________________________________________#
    #                                                                                   #
    # ---------------    Insertion des donnees dans la table photo     ---------------- #
    #___________________________________________________________________________________#


    # Trouver la valeur maximale de idpho dans la table photo
    max_idpho = 0
    with arcpy.da.SearchCursor(p_photo, ["idpho"]) as cursor:
        for row in cursor:
            if row[0] is not None and row[0] > max_idpho:
                max_idpho = row[0]

    # Champs à utiliser pour les photos
    sf_ph_attach = ["ATT_NAME", "REL_GLOBALID"]  # Champs de repeat_poi__ATTACH
    tf_ph_attach = ["nom_fichier"]

    # Champs de repeat_poi pour les photos
    photo_fields = ["auteur_photo_", "credit_photo_", "date_photo_", "premiere_photo_"]

    def process_photos(photo_suffix, max_idpho):
        sf_ph = [field + photo_suffix for field in photo_fields] + ["GlobalID"]
        tf_ph = ["auteur", "credit_photo", "date_acquis", "premiere_photo"]

        # Utiliser SearchCursor pour lire les données de la table source (repeat_poi)
        with arcpy.da.SearchCursor(p_repeat_poi, sf_ph) as search_cursor_repeat_poi:
            # Utiliser InsertCursor pour insérer les données dans la table cible (p_photo)
            with arcpy.da.InsertCursor(p_photo, ["idpho"] + tf_ph_attach + tf_ph) as insert_cursor:
                for row_repeat_poi in search_cursor_repeat_poi:
                    global_id = row_repeat_poi[-1]  # Extraire GlobalID
                    if global_id in attach_dict:
                        attach_row = attach_dict[global_id]
                        target_row_ph = []

                        # Ajouter une nouvelle valeur unique pour idpho
                        max_idpho += 1
                        target_row_ph.append(max_idpho)
                        id_photo.append(max_idpho)

                        # Ajouter les valeurs des champs ATT_NAME
                        for field in sf_ph_attach[:-1]:  # Exclure REL_GLOBALID
                            target_row_ph.append(attach_row[sf_ph_attach.index(field)])

                        # Ajouter les valeurs des champs repeat_poi
                        for field in sf_ph[:-1]:  # Exclure GlobalID
                            if "date_photo_" in field and row_repeat_poi[sf_ph.index(field)]:
                                date_photo = row_repeat_poi[sf_ph.index(field)]
                                target_row_ph.append(date_photo)
                            else:
                                target_row_ph.append(row_repeat_poi[sf_ph.index(field)])

                        # Insérer la ligne dans la table cible
                        insert_cursor.insertRow(target_row_ph)
        return max_idpho

    # Utiliser SearchCursor pour lire les données de la table source (repeat_poi__ATTACH)
    attach_dict = {}
    with arcpy.da.SearchCursor(p_attach, sf_ph_attach) as search_cursor_attach:
        for row_attach in search_cursor_attach:
            attach_dict[row_attach[-1]] = row_attach[:-1]  # Associer REL_GLOBALID à ATT_NAME et autres champs

    # Processus pour la première photo (obligatoire)
    max_idpho = process_photos("1", max_idpho)

    # Champs additionnels pour vérifier si la photo 2 et 3 doivent être ajoutées
    check_fields = ["GlobalID", "ajouter_photo2", "ajouter_photo3"]

    # Utiliser SearchCursor pour vérifier les champs "ajouter_photo_2" et "ajouter_photo_3"
    with arcpy.da.SearchCursor(p_repeat_poi, check_fields) as cursor:
        for row in cursor:
            global_id = row[0]
            ajouter_photo_2 = row[1]
            ajouter_photo_3 = row[2]

            if ajouter_photo_2 == "Oui":
                max_idpho = process_photos("2", max_idpho)
            if ajouter_photo_3 == "Oui":
                max_idpho = process_photos("3", max_idpho)    
    print(" -> Peuplement des photos effectué")



    #___________________________________________________________________________________#
    #                                                                                   #
    # --------  Peuplement des tables de relation groupe_poi et parcours_poi  -------- #
    #___________________________________________________________________________________#

    """
        1.	Ajouter les idpoi, idgroupe, idparcours à des listes (fait plus haut)
        2.	Ajouter ces id aux tables Formulaire_1 et repeat_poi
        3.	Joindre ces deux tables entre globalid et parentglobalid
        4.	Insérer les lignes dans la table de relation
    """

    # -- Ajouter l'idpoi généré tantôt à la table repeat_poi -- #

    field_name = "idpoi"

    # Démarrez une session d'édition sur la table p_repeat_poi
    edit_session = arcpy.da.Editor(p_fgdb)
    edit_session.startEditing(False, True)  

    # Ouvrir un curseur de mise à jour pour mettre à jour le champ idpoi
    with arcpy.da.UpdateCursor(p_repeat_poi, field_name) as cursor:
        for row, new_id in zip(cursor, id_poi):
            row[0] = new_id[0]  
            cursor.updateRow(row)


    print(" -> Ajout des idpoi à la table repeat_poi")



    # -- Ajouter l'idparcours et l'idgroupe généré tantôt à la table Formulaire_1 -- #

    field_name_parcours = "idparcours"
    field_name_groupe = "idgroupe"

    # Ouvrir un curseur de mise à jour pour mettre à jour les champs idparcours et idgroupe dans la table p_formulaire_1
    with arcpy.da.UpdateCursor(p_formulaire_1, field_name_groupe, test_groupe) as cursor_g:
        for row, new_id_g in zip(cursor_g, id_groupe):  
            row[0] = new_id_g[0]  
            cursor_g.updateRow(row)
    print(" -> Ajout des idgroupe à la table repeat_poi")


    # Ouvrir un curseur de mise à jour pour mettre à jour les champs idparcours et idgroupe dans la table p_formulaire_1
    with arcpy.da.UpdateCursor(p_formulaire_1, field_name_parcours, test_parcours) as cursor_p:
        for row, new_id_p in zip(cursor_p, id_parcours):  
            row[0] = new_id_p[0] 
            cursor_p.updateRow(row)
    print(" -> Ajout des idparcours à la table repeat_poi")


    edit_session.stopEditing(True)  # True pour sauvegarder les modifications


    # -- Joindre les tables repeat_poi et formulaire_1 dans une table jointure_1 
    # -- pour obtenir dans une même table la correspondance entre les idpoi, idgroupe -- #

    #si p_jointure_1 existe, on la supprime
    if arcpy.Exists(p_jointure_1):
            arcpy.management.Delete(p_jointure_1)

    temp_jointure1 = arcpy.management.AddJoin(p_repeat_poi, "parentglobalid", p_formulaire_1, "globalid", "KEEP_ALL")
    arcpy.conversion.ExportFeatures(temp_jointure1, p_jointure_1)


    # -- Faire un append des idpoi, idgroupe et description à la table de relation poi_groupe -- #
    sf_idpoi_idgroupe = ["idpoi", 
                         "idgroupe", 
                         "description_generique"]
    
    tf_idpoi_idgroupe = ["idpoi", 
                         "idgroupe",
                          "description"]


    #si p_groupe_poi_temp existe, on la supprime
    if arcpy.Exists(p_groupe_poi_temp):
            arcpy.management.Delete(p_groupe_poi_temp)

    arcpy.management.CreateTable(p_defaut_gdb, "p_groupe_poi_temp", p_groupe_poi)
    arcpy.management.CopyRows(p_groupe_poi, p_groupe_poi_temp)

    #Insersion dans groupe_poi
    with arcpy.da.SearchCursor(p_jointure_1, sf_idpoi_idgroupe, where_clause=test_groupe) as search_cursor:
        with arcpy.da.InsertCursor(p_groupe_poi_temp, tf_idpoi_idgroupe) as insert_cursor :
            for row in search_cursor :
                insert_poi_groupe_temp = [row[0], row[1], row[2]]
                insert_cursor.insertRow(insert_poi_groupe_temp)

    print(" -> Peuplement table de relation groupe_poi effectué")



    #si p_groupe_poi existe, on la supprime pour permettre le copyrows
    if arcpy.Exists(p_groupe_poi):
            arcpy.management.Delete(p_groupe_poi)

    arcpy.management.CopyRows(p_groupe_poi_temp, p_groupe_poi)


    #si p_parcours_poi_temp existe, on la supprime
    if arcpy.Exists(p_parcours_poi_temp):
            arcpy.management.Delete(p_parcours_poi_temp)

    arcpy.management.CreateTable(p_defaut_gdb, "p_parcours_poi_temp", p_parcours_poi)
    arcpy.management.CopyRows(p_parcours_poi, p_parcours_poi_temp)


    #Peuplement poi_parcours
    sf_idpoi_idparcours = ["idpoi", "idparcours", "description_poi_parcours", "odre_poi_parcours"]
    tf_idpoi_idparcours = ["idpoi", "idparcours", "description", "ordre"]

    #Insersion dans parcours_poi
    with arcpy.da.SearchCursor(p_jointure_1, sf_idpoi_idparcours, where_clause=test_parcours) as search_cursor:
        with arcpy.da.InsertCursor(p_parcours_poi_temp, tf_idpoi_idparcours) as insert_cursor :
            for row in search_cursor :
                insert_poi_parcours_temp = [row[0], row[1], row[2], row[3]]
                insert_cursor.insertRow(insert_poi_parcours_temp)


    #si p_groupe_poi existe, on la supprime pour permettre le copyrows
    if arcpy.Exists(p_parcours_poi):
            arcpy.management.Delete(p_parcours_poi)


    arcpy.management.CopyRows(p_parcours_poi_temp, p_parcours_poi)


    #arcpy.management.CopyRows(p_groupe_poi_temp, p_groupe_poi)
    arcpy.management.DeleteRows(p_groupe_poi_temp)
    arcpy.management.DeleteRows(p_parcours_poi_temp)

    print(" -> Peuplement table de relation parcours_point_interet effectué")


    #___________________________________________________________________________________#
    #                                                                                   #
    # --- Peuplement de la table de relation poi_photo_groupe et poi_photo_parcours --- #
    #___________________________________________________________________________________#


    field_name = "id_pho"

    # Vérifier si le champ existe
    fields = arcpy.ListFields(p_jointure_1)

    field_exists = any(field.name == field_name for field in fields)

    # Si le champ n'existe pas, ajoutez-le
    if not field_exists:
        arcpy.management.AddField(p_jointure_1, field_name, "LONG")


    edit_session = arcpy.da.Editor(p_defaut_gdb)
    edit_session.startEditing(False, True)  

    #Ajouter l'id_photo à la table p_jointure_1
    with arcpy.da.UpdateCursor(p_jointure_1, field_name) as cursor:
        for row, new_id in zip(cursor, id_photo):
            row[0] = new_id  
            cursor.updateRow(row)

    edit_session.stopEditing(True)  

    #Ici, série de jointure pour assembler toutes les données nécessaires (idpoi, idparcours, idgroupe, idphoto, parcours_groupe, nom de la photo)
    if arcpy.Exists(p_jointure_5):
        arcpy.management.Delete(p_jointure_5)

    if arcpy.Exists(p_jointure_2):
        arcpy.management.Delete(p_jointure_2)

    temp_jointure2 = arcpy.management.AddJoin(p_attach, "REL_GLOBALID", p_repeat_poi, "globalid", "KEEP_ALL")
    arcpy.management.CopyRows(temp_jointure2, p_jointure_2)

    temp_jointure5 = arcpy.management.AddJoin(p_jointure_1, "parentglobalid", p_jointure_2, "repeat_poi_parentglobalid", "KEEP_ALL")
    arcpy.management.CopyRows(temp_jointure5, p_jointure_5)

    if arcpy.Exists(p_jointure_3):
        arcpy.management.Delete(p_jointure_3)

    temp_jointure3 = arcpy.management.AddJoin(p_jointure_2, "repeat_poi_idpoi", p_groupe_poi, "idpoi", "KEEP_ALL")
    arcpy.management.CopyRows(temp_jointure3, p_jointure_3)

    temp_jointure4 = arcpy.management.AddJoin(p_jointure_1, "parentglobalid", p_jointure_3, "jointure_2_repeat_poi_parentglobalid", "KEEP_ALL")
    arcpy.management.CopyRows(temp_jointure4, p_jointure_4)

    sf_poi_pho_gr = ["jointure_1_idpoi",
                     "jointure_1_idgroupe",
                     "jointure_1_id_pho"]

    tf_poi_pho_gr = ["idpoi",
                     "idgroupe",
                     "idpho"]

    test_poi_pho_gr = "jointure_1_parcours_groupe = 'groupe'"


    #Insersion des informations de joniture_4 dans la table poi_photo_groupe
    with arcpy.da.SearchCursor(p_jointure_4, sf_poi_pho_gr, where_clause=test_poi_pho_gr) as search_cursor:
        with arcpy.da.InsertCursor(p_poi_photo_groupe, tf_poi_pho_gr) as insert_cursor :
            for row in search_cursor :
                insert_poi_pho_gr = [row[0], row[1], row[2]]
                insert_cursor.insertRow(insert_poi_pho_gr)


    sf_poi_pho_pa = ["jointure_1_idpoi",
                     "jointure_1_idparcours",
                     "jointure_1_id_pho"]

    tf_poi_pho_pa = ["idpoi",
                     "idparcours",
                     "idpho"]

    test_poi_pho_pa = "jointure_1_parcours_groupe = 'parcours'"


    #Insersion des informations de joniture_4 dans la table poi_photo_parcours
    with arcpy.da.SearchCursor(p_jointure_4, sf_poi_pho_pa, where_clause=test_poi_pho_pa) as search_cursor:
        with arcpy.da.InsertCursor(p_poi_photo_parcours, tf_poi_pho_pa) as insert_cursor :
            for row in search_cursor :
                insert_poi_pho_pa = [row[0], row[1], row[2]]
                insert_cursor.insertRow(insert_poi_pho_pa)

    print(" -> Peuplement table de relation poi_photo_groupe effectué ")

if __name__ == "__main__":
    peuplement()