#rR gscope_macsimsql.tcl

proc IsPk Text {
    return [regexp {^[0-9]+$} $Text]
}

proc ConvertToPkMacsSeq {aMacs {aSeq ""}} {
    upvar $aMacs Macs
    if {$aSeq!=""} { upvar $aSeq  Seq } else { set Seq 1 }
    if { ! [IsPk $Macs]} { set Macs [SqlExec "select pk_macsims from macsims where name = '$Macs'"] }
    if { ! [IsPk $Macs]} { return 0 }
    if { ! [IsPk $Seq]} { set Seq [SqlExec "select pk_seq from seq where name='$Seq' and pk_macsims=$Macs"] }
    if { ! [IsPk $Seq]} { return 0 }
    return 1
}

proc QueryMacsimsLinkedInfo {Macs Seq Table} {

    CanalSqlMacsims
    if { ! [ConvertToPkMacsSeq Macs Seq]} { return ""}

    set Sql "select t.* from $Table t , ln_seq_$Table ln where ln.pk_seq=$Seq and ln.pk_$Table=t.pk_$Table"
    return [SqlExec $Sql "GetList"]
}

proc QueryMacsimsSeqInfo {Macs Seq Type {GetWhat ""}} {

    CanalSqlMacsims
    if { ! [ConvertToPkMacsSeq Macs Seq]} { return ""}

    if {$Type == "ListOfType"} {
	set Sql "select distinct TYPE from SEQINFO where PK_SEQ=$Seq"
	if {[regexp "^order by " $GetWhat]} { append Sql " $GetWhat" ; set GetWhat "GetList" }
	if {$GetWhat==""} { set GetWhat "GetList" }
	return [SqlExec $Sql $GetWhat]
    }

    if {$Type == "x" || $Type == "ListOfTypeValue" } {
	set Sql "select TYPE, VALUE from SEQINFO where PK_SEQ=$Seq"
	if {[regexp "^order by " $GetWhat]} { append Sql " $GetWhat" ; set GetWhat "GetList" }
	if {$GetWhat==""} { set GetWhat "GetList" }
	return [SqlExec $Sql $GetWhat]
    }

    set Sql "select VALUE from SEQFEATURE where TYPE='$Type' and PK_SEQ=$Seq"
    if {[regexp "^order by " $GetWhat]} { append Sql " $GetWhat" ; set GetWhat "GetList" }
    return [SqlExec $Sql $GetWhat]
}
  
proc QueryMacsimsSeqFeature {Macs Seq FType {Key ""} {GetWhat ""}} {

    CanalSqlMacsims
    if { ! [ConvertToPkMacsSeq Macs Seq]} { return ""}

    if {[regexp -nocase {ListOfFType} $FType] } {
	set Sql "select distinct FTYPE from SEQFEATURE where PK_SEQ=$Seq"
	if {[regexp -nocase "^order by |^Get" $Key]} { set GetWhat $Key }
	if {[regexp -nocase "^order by " $GetWhat]} { append Sql " $GetWhat" ; set GetWhat "GetList" }
	if {$GetWhat==""} { set GetWhat "GetList" }
	return [SqlExec $Sql $GetWhat]
    }

    if {[regexp -nocase {\*|x|ListOfAll} $FType] } {
	set Sql "select * from SEQFEATURE where PK_SEQ = $Seq"
	if {[regexp -nocase "^order by |^Get" $Key]} { set GetWhat $Key }
	if {[regexp -nocase "^order by " $GetWhat]} { append Sql " $GetWhat" ; set GetWhat "GetList" }
	if {$GetWhat==""} { set GetWhat "GetList" }
	return [SqlExec $Sql $GetWhat]
    }

    if {[regexp -nocase {\*|x} $Key] } { set Key "*" }
    set Sql "select $Key from SEQFEATURE where FTYPE = '$FType' and PK_SEQ = $Seq"
    if {[regexp "^order by " $GetWhat]} { append Sql " $GetWhat" ; set GetWhat "GetList" }
    if {$GetWhat==""} { set GetWhat "GetList" }
    Espionne $Sql
    return [SqlExec $Sql $GetWhat]
}
  
proc QueryMacsimsSeq {Macs {Seq ""} {Key ""} {GetWhat ""}} {
    CanalSqlMacsims
    if {$Seq==""} { set Seq "ListOf" }
    if {$Key==""} { set Key "NAME" }
    if {[regexp -nocase {\*|x} $Key] } {
	set Key "*"
	if {$GetWhat==""} { set GetWhat "GetList" }
    }
    if {$Seq=="ListOf"} {
	set Sql "select $Key from SEQ s where s.PK_MACSIMS=$Macs"
	if {[regexp "^order by " $GetWhat]} {
	    append Sql " $GetWhat"
	    set GetWhat "GetList" 
	}
	if {$GetWhat==""} { set GetWhat "GetList" }
	return [SqlExec $Sql $GetWhat]
    }
    if { ! [ConvertToPkMacsSeq Macs Seq]} { return ""}
    set Sql "select $Key from SEQ s where s.PK_MACSIMS=$Macs and s.PK_SEQ=$Seq"
    if {[regexp "^order by " $GetWhat]} {
	append Sql " $GetWhat"
	set GetWhat "GetList" 
    }
    return [SqlExec $Sql $GetWhat]
}

proc QueryMacsims {{Qui ""} {Quoi ""} {Key ""} {Where ""} {Order ""} {GetWhat ""}} {


    if {$Key=="x"} { set Key "*" }

    CanalSqlMacsims
    if {[regexp "^select" $Qui]} {
	if {$GetWhat==""} { set GetWhat "GetList" }
	return [SqlExec $Qui $GetWhat]
    }

    if {[IsColsConsFreeSurf $Qui]} {
    }

    if {$Qui ==""} { set Qui "ListOf" }

    if {$Qui == "ListOf"} {
	if {$GetWhat==""} { set GetWhat "GetList" }
	set Table $Quoi
	if {$Table==""} { set Table "macsims" }
	if {$Key ==""} { set Key "pk_$Table" }
	set LesValeurs [SqlExec "select $Key from $Table $Where $Order" $GetWhat]
	return $LesValeurs
    }

    set Table $Qui
    set Qui $Quoi
    if {$Where == ""} {
	if {[IsPk $Qui]} {
	    set Where "where pk_$Table = $Qui" 
	} else {
	    set Where "where name ilike '$Qui'" 
	}
    }
    if {$GetWhat=="" &&	[regexp {[\*\,]} $Key]} { set GetWhat "GetList" }
    set LesValeurs [SqlExec "select $Key from $Table $Where $Order" $GetWhat]
    return $LesValeurs
}

proc GetFreetextFromSql Nom {
    set Retour [SqlExec "select FREETEXT from MACSIMS \
		    where FREETEXT like '%GscopeID $Nom\n%'" "GetFirstValue"]
    Espionne $Retour
    exit
}

proc GetMacsimSFromSql Nom {
    set Retour [SqlExec "select MACSIMSXML from MACSIMS \
		    where FREETEXT like '%GscopeID $Nom\n%'" "GetFirstValue"]
    Espionne $Retour
    exit
}

proc InsCommun {} {
    set FichierSqlCommun "[RepertoireDuGenome]/InsCommuns.sql"
    foreach Nom [ListeDesPABs] {
	set FichierSql [GscopeFile $Nom "macsimSql"]
	if {[FileAbsent $FichierSql]} { continue }
	lappend LeCommun [ContenuDuFichier $FichierSql]
    }
    return [SauveLesLignes $LeCommun dans $FichierSqlCommun]
}

proc ExtDbEntry Accession {
    return $Accession
}

proc ClustName Owner {
    return $Owner
}

proc MacsimsCodification {SX El} {
    global MacsimsCodification

    set El [string tolower $El]

    if {[info exists MacsimsCodification($SX,$El)]}     { return $MacsimsCodification($SX,$El) }
    if {[info exists MacsimsCodification("EstCharge")]} { return $Ele }
    set MacsimsCodification("EstCharge") 1
    set MacsimsCodification(Sql,macsim)                   "MACSIMS"
    set MacsimsCodification(Sql,alignment)                "MACSIMS"
    set MacsimsCodification(Sql,sequence)                 "SEQ"
    set MacsimsCodification(Sql,column-score)             "COLSCORE"
    set MacsimsCodification(Sql,freetext)                 "FREETEXT"
    set MacsimsCodification(Sql,consensus)                "CONSENSUS"
    set MacsimsCodification(Sql,surface-accessibility)    "SURFACC"

    set MacsimsCodification(Xml,macsims)                  "macsim"
    set MacsimsCodification(Xml,alignment)                "aln"
    set MacsimsCodification(Xml,sequence)                 "seq"
    set MacsimsCodification(Xml,column-score)             "colsco"
    set MacsimsCodification(Xml,freetext)                 "freetext"
    set MacsimsCodification(Xml,consensus)                "cons"
    set MacsimsCodification(Xml,surface-accessibility)    "suracc"

    set MacsimsCodification(ListOf,keys) [lsort -unique [array names MacsimsCodification]]
    return [MacsimsCodification $SX $El]
}

proc IsColsConsFreeSurf Word {
    set LesIsColsConsFreeSurf [list "column-score" "consensus" "freetext" "surface-accessibility" "colscor" "consensus" "freetext" "surfacc"]
    set i [lsearch $LesIsColsConsFreeSurf $Word]
    return [expr $i >= 0]
}

proc NodeSequence NodeName {
    return [string equal $NodeName "sequence"]
}

proc CreateSqlFromXmlMacsimsPourTous {} {
    
    CanalSqlMacsims

    CreateDirIfAbsent [GscopeSubDir "macsimSql"]
    foreach Nom [ListeDesPABs] {
	Espionne $Nom
	set FichierSql [GscopeFile $Nom "macsimSql"]
#	if {[FileExists $FichierSql]} { Espionne "$FichierSql already exists" ; continue }
	set FichierXml [GscopeFile $Nom "macsimXml"]
	if {[FileAbsent $FichierXml]} { Espionne "$FichierXml doesn't exist" ; continue }
	set Status [CreateSqlFromXmlMacsims $FichierXml $FichierSql]
    }
}

proc CreateSqlFromXmlMacsimsFromDirectory {{Dir ""} {Ext ""}} {
    
    if {$Ext==""} { set Ext ".xml" }
    if {$Dir==""} { set Dir [ChoixDuRepertoire] }

    CanalSqlMacsims

#   CreateDirIfAbsent [GscopeSubDir "macsimSql"]
    foreach File [glob -nocomplain "$Dir/*$Ext"] {
	Espionne $File
	regsub "$Ext" $File "" FichierSql
	append FichierSql ".sql"
	set FichierSql "/dev/null"
#	if {[FileExists $FichierSql]} { Espionne "$FichierSql already exists" ; continue }
	set FichierXml $File
	if {[FileAbsent $FichierXml]} { Espionne "$FichierXml doesn't exist" ; continue }
	set Status [CreateSqlFromXmlMacsims $FichierXml $FichierSql]
    }
}

proc CreateSqlFromXmlMacsims {NomOuFichier {FichierSql ""}} {

    package require tdom

    CanalSqlMacsims

    set Nom [file tail $NomOuFichier]
    while 1 {
	set FichierXml $NomOuFichier
	if {[regexp "/" $FichierXml]} { break }
	if { ! [EstUnPAB $Nom]} { break }
	set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom"
	if {[file exists $FichierXml]} { break }
	set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom.xml"
	if {[file exists $FichierXml]} { break }
	return ""
    }

    if {$FichierSql=="macsimSql"} {
	if {[regexp "/macsimXml/" $FichierXml]} {
	     regsub "/macsimXml/" $FichierXml "/macsimSql/" FichierSql
	} else {
	    set FichierSql $FichierXml
	}
	regsub ".xml$" $FichierSql "" FichierSql
	append FichierSql ".sql"
	set RepSql [file dirname $FichierSql]
	if {[DirAbsent $RepSql]} {file mkdir $RepSql}
    }
#    if {[FileExists $FichierSql]} { file delete $FichierSql }
    set FichierSql [LogInsUpDelPourExec "InFile" $FichierSql]

    set MacsimsXml [ContenuDuFichier $FichierXml]
    set NoeudMacsims [[dom parse $MacsimsXml] documentElement]


    set NoeudAli [$NoeudMacsims selectNodes "alignment"]
    set AlnName  [$NoeudAli selectNodes "string(aln-name)"]
    set AlnScore [$NoeudAli selectNodes "string(aln-score)"]
    set AlnNote  [$NoeudAli selectNodes "string(aln-note)"]

    set LeFreetext [list "Macsims sql database created by Gscope [Date NiceSeconds]"]
    if {[OnTraiteSpine]} {
	set GscopeID  $Nom
	set SpineID   [ExtraitInfo $Nom "SpineID"]
	set SpineRef  [ExtraitInfo $Nom "SpineRef"]
	set SpineDef  [ExtraitInfo $Nom "SpineDef"]
	set SpineHRef [H_Href $SpineRef [WgetzSurWeb $SpineRef "" "GetUrl"]]

	lappend LeFreetext "GscopeID $GscopeID"
	lappend LeFreetext "Alias [Alias $Nom]"
	lappend LeFreetext "SpineID $SpineID"
	lappend LeFreetext "SpineRef $SpineRef"
	lappend LeFreetext "SpineDef $SpineDef"
	lappend LeFreetext "SpineHRef $SpineHRef"
    }
    set Freetext [join $LeFreetext "\n"]

    set TexteMsf    ""
    set TexteMacsims $FichierXml
    set PkMacsims [SqlInsertOnceRecordIntoTable "+MACSIMS" \
	    NAME $AlnName \
	    SCORE $AlnScore \
	    NOTE $AlnNote \
	    MSF $TexteMsf \
	    MACSIMSXML $TexteMacsims]
    set AlreadyExists [regexp "already exists" $PkMacsims]

    scan $PkMacsims "%d" PkMacsims
    if {$AlreadyExists} {
	if {1 || [OuiOuNon "macsims $PkMacsims already exists. Do I skip it other information ?"]} {
	    LogInsUpDelPourExec "CloseFile"
	    return $FichierSql
	}
    } else {
	set GoodFreetext [QuoteEtBackslashPourSql $Freetext]
	SqlExec "update macsims set freetext='$GoodFreetext' where pk_macsims=$PkMacsims;"    
    }
    foreach NoeudLigne [$NoeudAli childNodes] {
	set NodeName [$NoeudLigne nodeName]
	if {[regexp {aln\-} $NodeName]} { continue }
	CreateSqlFromChildOfAlignment $NoeudLigne $PkMacsims
    }
    LogInsUpDelPourExec "CloseFile"
    return $FichierSql
}

proc CreateSqlFromChildOfAlignment {Noeud PkMacsims} {
    global PosInAln
    global CommandeAFaireApres

    if { ! [info exists PosInAln]} { set PosInAln 0 }
    incr PosInAln

    set NodeName [$Noeud nodeName]
    set NodeName [string tolower $NodeName]

    if {[IsColsConsFreeSurf $NodeName]} {
	return [CreateSqlFromNodeColsConsFreeSurf $Noeud $NodeName $PkMacsims $PosInAln]
    }

    if {[NodeSequence $NodeName]} {
	return [CreateSqlFromNodeSequence $Noeud $NodeName $PkMacsims $PosInAln]
    }

    FaireLire "Unknown nodename $NodeName"
    return ""
}

proc CreateSqlFromNodeSequence {Noeud NodeName PkMacsims PosInAln} {
    set NoeudSeqAli $Noeud
    set SeqName [$NoeudSeqAli selectNodes "string(seq-name)"]
    set SeqData [$NoeudSeqAli selectNodes "string(seq-data)"]
    regsub -all -nocase {[^\.\-A-Z]} $SeqData "" SeqData
    regsub -all -nocase {[^A-Z]} $SeqData "" SeqDataNoGap

    set Type "Protein"

    set PkSeq [SqlInsertRecordIntoTable "SEQ" \
	    PK_MACSIMS $PkMacsims \
	    NAME       $SeqName \
	    TYPE       $Type \
	    DATA       $SeqData \
	    DATANOGAP  $SeqDataNoGap \
	    POSINALN   $PosInAln]
    set Clef "SEQ,$PkMacsims,$SeqName"
    if {[info exists CommandeAFaireApres($Clef)]} {
	foreach CommandeAFaire $CommandeAFaireApres($Clef) {
	    eval $CommandeAFaire
	}
	unset CommandeAFaireApres($Clef)
    }

    set NoeudInfos  [$NoeudSeqAli selectNodes "seq-info"]

    foreach NoeudInfo [$NoeudInfos childNodes] {
	set NodeName [$NoeudInfo nodeName]

	if {$NodeName=="accession"} {
	    set DbName ""
	    set Accession [$NoeudInfo selectNodes "string()"]
	    set PkExtDbEntry [ValeurPk [SqlInsertOnceRecordIntoTable "EXTDBENTRY" \
		    DBNAME $DbName \
		    VALUE $Accession]]
	    set Status [SqlInsertOnceRecordIntoTable "LN_SEQ_EXTDBENTRY" \
		    PK_SEQ $PkSeq \
		    PK_EXTDBENTRY $PkExtDbEntry]
	    continue
	}
	if {$NodeName=="organism"} {
	    set GenreEspece [$NoeudInfo selectNodes "string()"]
	    regsub {\.} $GenreEspece " " GenreEspece
	    set Genre ""
	    set Espece ""
	    scan $GenreEspece "%s %s" Genre Espece
	    set PkTaxonomy [SqlExec "select PK_TAXONOMY from TAXONOMY \
		    where name like '$Genre $Espece'" "GetFirstValue"]
	    if {$PkTaxonomy==""} { continue } 
	    set Status [SqlInsertOnceRecordIntoTable "LN_SEQ_TAXONOMY" \
		    PK_SEQ $PkSeq \
		    PK_TAXONOMY $PkTaxonomy]
	    continue
	}
	if {$NodeName=="taxid"} {
	    set TaxId [$NoeudInfo selectNodes "string()"]
	    set PkTaxonomy [SqlExec "select PK_TAXONOMY from TAXONOMY where PK_TAXONOMY=$TaxId" "GetFirstValue"]
	    if {$PkTaxonomy==""} { continue } 
	    set Status [SqlInsertOnceRecordIntoTable "LN_SEQ_TAXONOMY" \
		    PK_SEQ $PkSeq \
		    PK_TAXONOMY $PkTaxonomy]
	    continue
	}
	if {$NodeName=="keywordlist"} {
	    foreach NoeudKeywordList [$NoeudInfo selectNodes "string(keywordlist)"] {
		foreach NoeudKeyword [$NoeudKeywordList childNodes] {
		    set Keyword [$NoeudKeyword selectNodes "string()"]
		    set PkKeyword [ValeurPk [SqlInsertOnceRecordIntoTable "KEYWORD" \
			    VALUE $Keyword]]
		    set Status [SqlInsertOnceRecordIntoTable "LN_SEQ_KEYWORD" \
			    PK_SEQ $PkSeq \
			    PK_KEYWORD $PkKeyword]
		    continue		    
		}
	    }
	    continue
	}
	if {$NodeName=="goxreflist"} {
	    foreach NoeudGoxrefList [$NoeudInfo selectNodes "string(goxreflist)"] {
		foreach NoeudGoxref [$NoeudGoxrefList childNodes] {
		    set GoId       [$NoeudGoxref selectNodes "string(goid)"]
		    set GoClass    [$NoeudGoxref selectNodes "string(goclass)"]
		    set GoDesc     [$NoeudGoxref selectNodes "string(godesc)"]
		    set GoEvidence [$NoeudGoxref selectNodes "string(goevidence)"]
		    set PkGoxref [ValeurPk [SqlInsertOnceRecordIntoTable "GOXREF" \
						GOID $GoId \
						GOCLASS $GoClass \
						GODESC $GoDesc \
						GOEVIDENCE $GoEvidence ]]
		    set Status [SqlInsertOnceRecordIntoTable "LN_SEQ_GOXREF" \
				    PK_SEQ $PkSeq \
				    PK_GOXREF $PkGoxref]
		    continue
		}
	    }
	    continue
	}

	if {$NodeName=="ftable"} {
	    set NoeudFtable $NoeudInfo
	    foreach NoeudFitem [$NoeudFtable selectNodes "fitem"] {
		set Ftype  [$NoeudFitem selectNodes "string(ftype)"]
		set Fstart [$NoeudFitem selectNodes "string(fstart)"]
		set Fstop  [$NoeudFitem selectNodes "string(fstop)"]
		set Fcolor [$NoeudFitem selectNodes "string(fcolor)"]
		set Fscore [$NoeudFitem selectNodes "string(fscore)"]
		set Fnote  [$NoeudFitem selectNodes "string(fnote)"]
		set Status [SqlInsertRecordIntoTable SEQFEATURE \
			PK_SEQ      $PkSeq \
			FTYPE       $Ftype \
			FSTART      $Fstart \
			FSTOP       $Fstop \
			FCOLOR      $Fcolor \
			FSCORE      $Fscore \
			FNOTE       $Fnote \
			FSTATUS     $Status ]
	    }
	    continue
	}
	if {$NodeName=="lineage"} {
	    set LesTaxons {}
	    foreach NoeudTaxon [$NoeudInfo childNodes] {
		set Taxon [$NoeudTaxon selectNodes "string()"]
		lappend LesTaxons $Taxon
	    }
	    set Lineage [join $LesTaxons "; "]
	    set PkInfo [SqlInsertRecordIntoTable SEQINFO \
		    PK_SEQ $PkSeq \
		    TYPE   "lineage" \
		    VALUE  $Lineage]
	    continue
	}
	

	set Info [$NoeudInfo selectNodes "string()"]
	set PkInfo [SqlInsertRecordIntoTable SEQINFO \
		PK_SEQ $PkSeq \
		TYPE   $NodeName \
		VALUE  $Info]

	if {$NodeName=="group"} {
	    set G $Info
	    set ClustName "group_$G"
	    set PkClust [ValeurPk [SqlInsertOnceRecordIntoTable "CLUST" \
		    PK_MACSIMS $PkMacsims \
		    NAME       $ClustName]]
	    SqlExec "update SEQ set PK_CLUST=$PkClust where PK_SEQ=$PkSeq" 
	}
	continue 
    }
}

proc CreateSqlFromNodeColsConsFreeSurf {Noeud NodeName PkMacsims PosInAln} {
    global CommandeAFaireApres

    set NomSql [MacsimsCodification "Sql" $NodeName]
    set NomXml [MacsimsCodification "Xml" $NodeName]
    
    set Name  [$Noeud selectNodes "string($NomXml-name)"]
    set Owner [$Noeud selectNodes "string($NomXml-owner)"]
    set Type  [$Noeud selectNodes "string($NomXml-type)"]
    set Data  [$Noeud selectNodes "string($NomXml-data)"]
    
#   if {[OuiOuNonMemo "je stoppe encore ici"]} {}
    if {$Owner==""} { set Owner "all" }
    if {[regexp {^[0-9]+$} $Owner]} {
	set Owner "group_$Owner"
    }

    set PkTable [SqlInsertRecordIntoTable $NomSql \
	    NAME  $Name \
	    TYPE  $Type \
	    DATA  $Data \
	    POSINALN $PosInAln]
    
    if {$Owner==0 || [string equal -nocase "all" $Owner]} {
	set Status [SqlInsertOnceRecordIntoTable "LN_MACSIMS_$NomSql" \
		PK_MACSIMS  $PkMacsims \
		PK_$NomSql $PkTable]
	return $Status
    }
    if {[regexp {^group_[0-9]+$} $Owner]} {
	set ClustName [ClustName $Owner]
	set Query "select PK_CLUST from CLUST \
		where PK_MACSIMS=$PkMacsims and NAME='$ClustName'"
	set PkClust [SqlExec $Query "GetFirstValue"]
	if {$PkClust==""} {
	    set PkClust [SqlInsertRecordIntoTable CLUST \
		    PK_MACSIMS $PkMacsims \
		    NAME     $ClustName ]
	}
	set Status [SqlInsertOnceRecordIntoTable "LN_CLUST_$NomSql" \
		PK_CLUST   $PkClust \
		PK_$NomSql $PkTable]
	return $Status
    }
    #rR owner = seqname   
    set Query "select PK_SEQ from SEQ \
	    where PK_MACSIMS=$PkMacsims and NAME='$Owner'"
    set PkSeq [SqlExec $Query "GetFirstValue"]
    set CommandeAFaire "SqlInsertOnceRecordIntoTable LN_SEQ_$NomSql \
	    PK_SEQ      \[set PkSeq\] \
	    PK_$NomSql  $PkTable"
    if {$PkSeq!=""} {
	set Status [eval $CommandeAFaire]
	return $Status
    } else {
	set Clef "SEQ,$PkMacsims,$Owner"
	lappend CommandeAFaireApres($Clef) $CommandeAFaire
#	Espionne "lappend CommandeAFaireApres($Clef) $CommandeAFaire"
	set Status "DefferedCommand $Clef"
	return $Status
    }	    
}