Quel urlrewriting avec $args ?

  • Auteur de la discussion Auteur de la discussion ortolojf
  • Date de début Date de début
O
ortolojf
WRInaute accro
Bonjour

Je cherche à faire l'urlrewriting d'une page appelée avec des paramètres précis, mais produits par une form html, donc il est quasiment impossible de savoir l'ordre des paramètres.

Le paramètre PARAM[] se présente donc comme ceci : PARAM%5B%5D , et je fait un map.

Il peut y avoir plusieurs PARAM[] dans la $querystring.

Le troisième map c'est pour fixer l'ordre des paramètres, et traduire $args en un string et les paramètres séparés par #.

Actuellement, rien ne passe, l'urlrewriting ne se fait pas.

Pouvez-vous m'aider à mettre au point cet urlrewriting ?

Merci beaucoup.



Code: 
    map (%5B|%5D) $brackets {
        %5B [;
        %5D ];
    }

    map $args $argsfromparams {
        PARAM$brackets$brackets=\d+ PAR[]=$arg_PARAM;
        default $args;
    }
       
    map $args $argsfromargs {
        ^(?:(ENTIERS=[\dt.-]+|MODE=\d|REDIRECT=\d|TEND=\d|PARAM$brackets$brackets=\d+|TAB_P=[\d.]*|AFFIC=\d|FIRST_PERIODE=\d+|LAST_PERIODE=\d+)&?)+$ ENT=$arg_ENTIERS#MO=$arg_MODE#RED=$arg_REDIRECT#TEN=$arg_TEND#TAB=$arg_TAB_P#AFF=$arg_AFFIC#FIRST=$arg_FIRST_PERIODE#LAST$arg_LAST_PERIODE#$argsfromparams;
        default $args;
    }
 
Dernière édition:
site-voyance
site-voyance
Nouveau WRInaute
Bonjour,

map (%5B|%5D) $brackets {
%5B "[";
%5D "]";
}

# Extraction des paramètres PARAM[]
map $args $argsfromparams {
~*PARAM\[\]=(\d+)(&|$) "PAR[]=$1";
~PARAM\[\]=(\d+)&(.)$ "PAR[]=$1#$argsfromparams";
default "";
}

# Réorganisation des paramètres dans l'ordre souhaité
map $args $argsfromargs {
~^(?:(ENTIERS=([^&]+)|MODE=(\d+)|REDIRECT=(\d+)|TEND=(\d+)|TAB_P=([^&]+)|AFFIC=(\d+)|FIRST_PERIODE=(\d+)|LAST_PERIODE=(\d+))&?)$ "ENT=$arg_ENTIERS#MO=$arg_MODE#RED=$arg_REDIRECT#TEN=$arg_TEND#TAB=$arg_TAB_P#AFF=$arg_AFFIC#FIRST=$arg_FIRST_PERIODE#LAST=$arg_LAST_PERIODE#$argsfromparams";
default $args;
}

# Règle de rewriting
location /votre-page-origine {
rewrite ^/votre-page-origine$ /nouvelle-page?$argsfromargs permanent;
}


Plusieurs erreurs :


  1. Problème de syntaxe dans la map $brackets : Les crochets étaient notés avec un point-virgule plutôt qu'avec des guillemets. J'ai remplacé [; par "[" et ]; par "]".
  2. Traitement des paramètres multiples PARAM[] : Votre configuration ne capturait pas correctement les multiples occurrences de PARAM[]. J'ai ajouté une expression régulière récursive pour traiter ce cas.
  3. Expression régulière trop restrictive : Votre regex dans la dernière map était trop rigide et n'acceptait que des valeurs numériques pour certains paramètres. J'ai assoupli les contraintes pour accepter plus de formats.
  4. Absence de règle de rewriting finale : J'ai ajouté une directive location avec la règle rewrite qui utilise le résultat des maps.
  5. Correction de la concaténation : Dans la dernière map, il manquait un signe égal pour le paramètre LAST : #LAST$arg_LAST_PERIODE devrait être #LAST=$arg_LAST_PERIODE.
 
O
ortolojf
WRInaute accro
Bonjour site-voyance

La récursion ne semble pas se faire.

Le paramètre PARAM[]=1 est le seul PARAM[] urlrewrité.

Je ne sais pas comment faire un map récursif.

Merci beaucoup de ton aide.

Sinon, j'ai remplacé les dièzes par des deux points ( : ).

Voici les logs sous localhost.



Code: 
=> avant rewriting : 127.0.0.1 - - [01/Apr/2025:19:01:51 +0200] "GET /courses-lendemain/pronostics-courses.html?ENTIERS=1-2t3t1t2.2056t0.0304&MODE=1&REDIRECT=1&TEND=3&PARAM[]=1&PARAM[]=2&PARAM[]=3&TAB_P=1.2.3.4.5.6.7.8.9.10.11&AFFIC=1&FIRST_PERIODE=8098&LAST_PERIODE=8099 HTTP/1.1" 301 169 "-" "curl/8.9.1"

=> après rewriting : 127.0.0.1 - - [01/Apr/2025:19:01:51 +0200] "GET /pwa.php?type=LEND_STATENT=1-2t3t1t2.2056t0.0304:MO=1:RED=1:TEN=3:TAB=1.2.3.4.5.6.7.8.9.10.11:AFF=1:FIRST=8098:LAST=8099:PAR[]=1 HTTP/1.1" 200 8796 "-" "curl/8.9.1"


map :
*****

map (%5B|%5D) $brackets {
%5B "[";
%5D "]";
}

# Extraction des paramètres PARAM[]
map $args $argsfromparams {
        ~*PARAM\[\]=(\d+)(&|$) "PAR[]=$1";
        ~PARAM\[\]=(\d+)&(.)$ "PAR[]=$1:$argsfromparams";
        default "";
}

# Réorganisation des paramètres dans l'ordre souhaité
map $args $argsfromargs {
~(?:(ENTIERS=([^&]+)|MODE=(\d)|REDIRECT=(\d)|TEND=(\d)|TAB_P=([^&]+)|AFFIC=(\d)|FIRST_PERIODE=(\d+)|LAST_PERIODE=(\d+))&?)$ "ENT=$arg_ENTIERS:MO=$arg_MODE:RED=$arg_REDIRECT:TEN=$arg_TEND:TAB=$arg_TAB_P:AFF=$arg_AFFIC:FIRST=$arg_FIRST_PERIODE:LAST=$arg_LAST_PERIODE:$argsfromparams";
default $args;
}


Règle de rewriting
******************
location  = /courses-lendemain/pronostics-courses.html {

        root /;

        rewrite ^/courses-lendemain/pronostics-courses\.html$ /pwa.php?type=LEND_STAT$argsfromargs? permanent;
}
 
O
ortolojf
WRInaute accro
Bonjour site-voyance

Il n'ya pas que des PARAM[] dans $args.

En ce qui concerne le map récursif :

Le token accédé récursivement

~PARAM\[\]=(\d+)&(.)$

est-il réellement trouvé ?

Le (.) correspond à un seul n'importe quel caractère avant la fin de ligne.

Ces tokens accédés semblent aller de l'avant vers l'arrière.

Ne serait-il pas mieux de les arranger de l'arrière vers l'avant ?

Et les tokens traduits

"PAR[]=$1:$argsfromparams"

vont de l'avant vers l'arrière.

La variable $argsfromparams

est-elle évaluée et affectée récursivement dans le map ?

Donc : un map peut-il être récursif ?

Merci beaucoup.
 
site-voyance
site-voyance
Nouveau WRInaute
map (%5B|%5D) $brackets {
%5B "[";
%5D "]";
}

# Extraction des paramètres PARAM[]
map $args $argsfromparams {
# Première occurrence
~^(.?)PARAM\[\]=([^&]+)(.*)$ "$1PAR[]=$2$argsfromparams_next";
# Si aucun paramètre PARAM[] n'est trouvé
default "";
}

# Récursion pour les paramètres suivants
map $3 $argsfromparams_next {
# S'il y a encore un PARAM[], ajouter un séparateur suivi du paramètre
~^(.?)PARAM\[\]=([^&]+)(.*)$ ":PAR[]=$2$argsfromparams_next";
# Si plus de PARAM[], terminer
default "";
}

# Réorganisation des paramètres dans l'ordre souhaité
map $args $argsfromargs {
~(?:(ENTIERS=([^&]+)|MODE=(\d)|REDIRECT=(\d)|TEND=(\d)|TAB_P=([^&]+)|AFFIC=(\d)|FIRST_PERIODE=(\d+)|LAST_PERIODE=(\d+))&?)$ "ENT=$arg_ENTIERS:MO=$arg_MODE:RED=$arg_REDIRECT:TEN=$arg_TEND:TAB=$arg_TAB_P:AFF=$arg_AFFIC:FIRST=$arg_FIRST_PERIODE:LAST=$arg_LAST_PERIODE:$argsfromparams";
default $args;
}

location = /courses-lendemain/pronostics-courses.html {
root /;
rewrite ^/courses-lendemain/pronostics-courses\.html$ /pwa.php?type=LEND_STAT$argsfromargs? permanent;
}
 
site-voyance
site-voyance
Nouveau WRInaute
Le problème vient de votre map $argsfromparams. La récursion n'est pas configurée correctement.
Pour tester cette configuration, redémarrez Nginx après avoir appliqué ces changements, et vérifiez les logs pour vous assurer que tous les paramètres PARAM[] sont correctement transmis.

Réessayer
O
 
O
ortolojf
WRInaute accro
Bonjour site voyance

Cà ne marche pas du tout.

L'urlewriting se fait, les noms des paramètres sont inchangés et les séparateurs sont l'éperluette ( & ).

L'url ne change pas après ou avant l'urlrewriting.

PARAM n'est pas nécessairement au début du request, le ^ du premier map ne faut-il pas l'enlever ?

Le $3 du deuxième map n'est théoriquement pas alimenté.

Efectivement si on pouvait avoir PARAM=\d+ en début de request, et compte tenu du fait que les PARAM se suivent, comment utiliser ~^ de manière récursive ?

Merci beaucoup de ton aide.


Code: 
map
***

map (%5B|%5D) $brackets {
%5B "[";
%5D "]";
}

# Extraction des paramètres PARAM[]
map $args $argsfromparams {
# Première occurrence
~^(.?)PARAM\[\]=([^&]+)(.*)$ "$1PAR[]=$2$argsfromparams_next";
# Si aucun paramètre PARAM[] n'est trouvé
default "";
}

# Récursion pour les paramètres suivants
map $3 $argsfromparams_next {
# S'il y a encore un PARAM[], ajouter un séparateur suivi du paramètre
~^(.?)PARAM\[\]=([^&]+)(.*)$ ":PAR[]=$2$argsfromparams_next";
# Si plus de PARAM[], terminer
default "";
}

# Réorganisation des paramètres dans l'ordre souhaité
map $args $argsfromargs {
~(?:(ENTIERS=([^&]+)|MODE=(\d)|REDIRECT=(\d)|TEND=(\d)|TAB_P=([^&]+)|AFFIC=(\d)|FIRST_PERIODE=(\d+)|LAST_PERIODE=(\d+))&?)$ "ENT=$arg_ENTIERS:MO=$arg_MODE:RED=$arg_REDIRECT:TEN=$arg_TEND:TAB=$arg_TAB_P:AFF=$arg_AFFIC:FIRST=$arg_FIRST_PERIODE:LAST=$arg_LAST_PERIODE:$argsfromparams";
default $args;
}

urlrewiting
***********
location  = /courses-lendemain/pronostics-courses.html {
        root /;
        rewrite ^/courses-lendemain/pronostics-courses\.html$ /pwa.php?type=LEND_STAT$argsfromargs? permanent;
}


relancement Nginx 
*****************
systemctl restart  nginx.service



requete HTTP
************

curl -L "http://localhost/courses-lendemain/pronostics-courses.html?ENTIERS=1-2t3t1t2.2056t0.0304&MODE=1&REDIRECT=1&TEND=3&PARAM[]=1&PARAM[]=2&PARAM[]=3&TAB_P=1.2.3.4.5.6.7.8.9.10.11&AFFIC=1&FIRST_PERIODE=8098&LAST_PERIODE=8099"


avant urlrewriting
******************

127.0.0.1 - - [02/Apr/2025:17:01:45 +0200] "GET /courses-lendemain/pronostics-courses.html?ENTIERS=1-2t3t1t2.2056t0.0304&MODE=1&REDIRECT=1&TEND=3&PARAM[]=1&PARAM[]=2&PARAM[]=3&TAB_P=1.2.3.4.5.6.7.8.9.10.11&AFFIC=1&FIRST_PERIODE=8098&LAST_PERIODE=8099qls HTTP/1.1" 301 169 "-" "curl/8.9.1"







après urlrewriting
******************

127.0.0.1 - - [02/Apr/2025:17:01:45 +0200] "GET /pwa.php?type=LEND_STATENTIERS=1-2t3t1t2.2056t0.0304&MODE=1&REDIRECT=1&TEND=3&PARAM[]=1&PARAM[]=2&PARAM[]=3&TAB_P=1.2.3.4.5.6.7.8.9.10.11&AFFIC=1&FIRST_PERIODE=8098&LAST_PERIODE=8099qls HTTP/1.1" 200 8789 "-" "curl/8.9.1"
 
site-voyance
site-voyance
Nouveau WRInaute
# Définir les variables pour chaque paramètre individuellement
map $arg_ENTIERS $ent {
"~.+" "ENT=$arg_ENTIERS";
default "";
}

map $arg_MODE $mo {
"~.+" "MO=$arg_MODE";
default "";
}

map $arg_REDIRECT $red {
"~.+" "RED=$arg_REDIRECT";
default "";
}

map $arg_TEND $ten {
"~.+" "TEN=$arg_TEND";
default "";
}

map $arg_TAB_P $tab {
"~.+" "TAB=$arg_TAB_P";
default "";
}

map $arg_AFFIC $aff {
"~.+" "AFF=$arg_AFFIC";
default "";
}

map $arg_FIRST_PERIODE $first {
"~.+" "FIRST=$arg_FIRST_PERIODE";
default "";
}

map $arg_LAST_PERIODE $last {
"~.+" "LAST=$arg_LAST_PERIODE";
default "";
}

# Construire la chaîne finale avec les séparateurs ":" seulement quand nécessaire
map $request_uri $param_string {
"~.*" "$ent${ent:+:}$mo${mo:+:}$red${red:+:}$ten${ten:+:}$tab${tab:+:}$aff${aff:+:}$first${first:+:}$last";
}

# Traiter les PARAM[] séparément car Nginx les met tous dans $arg_PARAM[]
map $arg_PARAM[] $param_array {
"~^(.+)$" "PAR[]=$arg_PARAM[]";
default "";
}

location = /courses-lendemain/pronostics-courses.html {
root /;

# Utiliser la variable $args pour extraire tous les PARAM[]
if ($args ~ "PARAM\[\]=([^&]+)") {
set $param1 "PAR[]=$1";
}
if ($args ~ "PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+)") {
set $param2 ":PAR[]=$2";
}
if ($args ~ "PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+)") {
set $param3 ":PAR[]=$3";
}

# Construire l'URL finale
set $final_params "${param_string}${param_string:+:}${param1}${param2}${param3}";

rewrite ^/courses-lendemain/pronostics-courses\.html$ /pwa.php?type=LEND_STAT$final_params permanent;
}

pour tester cette configuration :

# Redémarrez Nginx
systemctl restart nginx.service

# Testez avec curl et ajoutez -v pour voir les détails
curl -v -L "http://localhost/courses-lendemain/...&AFFIC=1&FIRST_PERIODE=8098&LAST_PERIODE=8099"
 
O
ortolojf
WRInaute accro
Bonjour site voyance

J'ai réussi à isoler les PARAM de $args.

$beginofparams ne contient plus que : PARAM[]=nbre1&PARAM[]=nbre2&PARAM[]=nbre3 etc...

Je sais maintenant que les map supportent la récursivité, après avoir tracé quelques tests.

Je verrai celà demain.


Code: 
# Extraction des paramètres PARAM[]
map $args $endofparams {
# Tous les PARAM plus la fin de $args.
~(&?PARAM\[\]=(?:\d+).*)$ "$1";
# Si aucun paramètre PARAM[] n'est trouvé
default "";
}

# Extraction des tokens PARAM seuls.
map $endofparams $beginofparams {
~((?:&?PARAM\[\]=(?:\d+))+).*$ "$1";
default "";
}
 
O
ortolojf
WRInaute accro
Bonjour site voyance

Je retiens ta solution :

if ($args ~ "PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+)") {

}

Dans mon cas, il y au maximum 12 PARAM.

Donc c'est faisable.

Finalement, n'y a-t-il aucune possibilité de rendre un map récursif ?

Ce serait une feature ou un bug de Nginx si c'était le cas ?

Merci beaucoup beaucoup pour ton aide. ;)
 
spout
spout
WRInaute accro
URL rewriting de l'an 40, c'est pas faute d'avoir dit je ne sais combien de fois sur WRI qu'une seule règle de rewrite permet de tout faire en SEO/user friendly.
 
O
ortolojf
WRInaute accro
Bonjour Spout

C'est précisément l'objet de ma demande.

Sachant une ligne ( url dégraissée par mes soins ) qui n'est pas contenue dans $args ( dégraissage oblige ), de la forme :

&PARAM[]=1&PARAM[]=2&PARAM[]=3 etc... ,

Comment faire un map récursif pour obtenir :

PAR[]=1:PAR[]=2:PAR[]=3 etc...

Merci beaucoup Spout.
 
O
ortolojf
WRInaute accro
Gagné

J'ai mis un : après LEND_STAT.

Cà marche super bien.

Merci beaucoup site voyance. ;)



Code: 
=> requête HTTP
   ************

curl -L "http://localhost/courses-lendemain/pronostics-courses.html?ENTIERS=1-2t3t1t2.2056t0.0304&MODE=1&REDIRECT=1&TEND=3&PARAM[]=1&PARAM[]=2&PARAM[]=3&TAB_P=1.2.3.4.5.6.7.8.9.10.11&AFFIC=1&FIRST_PERIODE=8098&LAST_PERIODE=8099"

=> logs Nginx
   **********

127.0.0.1 - - [05/Apr/2025:16:22:59 +0200] "GET /courses-lendemain/pronostics-courses.html?ENTIERS=1-2t3t1t2.2056t0.0304&MODE=1&REDIRECT=1&TEND=3&PARAM[]=1&PARAM[]=2&PARAM[]=3&TAB_P=1.2.3.4.5.6.7.8.9.10.11&AFFIC=1&FIRST_PERIODE=8098&LAST_PERIODE=8099 HTTP/1.1" 301 169 "-" "curl/8.9.1"
127.0.0.1 - - [05/Apr/2025:16:22:59 +0200] "GET /pwa.php?type=LEND_STAT:ENT=1-2t3t1t2.2056t0.0304:MO=1:RED=1:TEN=3:TAB=1.2.3.4.5.6.7.8.9.10.11:AFF=1:FIRST=8098:LAST=8099:PAR[]=1:PAR[]=3:PAR[]=3 HTTP/1.1" 200 8796 "-" "curl/8.9.1"


=> /etc/nginx/map.conf
   *******************

map (%5B|%5D) $brackets {
%5B "[";
%5D "]";
}

map $arg_ENTIERS $ent {
"~.+" ":ENT=$arg_ENTIERS";
default "";
}

map $arg_MODE $mo {
"~.+" ":MO=$arg_MODE";
default "";
}

map $arg_REDIRECT $red {
"~.+" ":RED=$arg_REDIRECT";
default "";
}

map $arg_TEND $ten {
"~.+" ":TEN=$arg_TEND";
default "";
}

map $arg_TAB_P $tab {
"~.+" ":TAB=$arg_TAB_P";
default "";
}

map $arg_AFFIC $aff {
"~.+" ":AFF=$arg_AFFIC";
default "";
}

map $arg_FIRST_PERIODE $first {
"~.+" ":FIRST=$arg_FIRST_PERIODE";
default "";
}

map $arg_LAST_PERIODE $last {
"~.+" ":LAST=$arg_LAST_PERIODE";
default "";
}

# Construire la chaîne finale avec les séparateurs ":" seulement quand nécessaire
map $request_uri $param_string {
"~.*" "$ent$mo$red$ten$tab$aff$first$last";
}


=> Je ne sais pas extraire PAR[]=[]
   --------------------------------

# Traiter les PARAM[] séparément car Nginx les met tous dans $arg_PARAM[]
map $arg_PARAM[] $param_array {
"~^(.+)$" "PAR[]=$arg_PARAM[]";
default "";
}


=> urlrewriting
   ************

location  = /courses-lendemain/pronostics-courses.html {

    root /;

    # Utiliser la variable $args pour extraire tous les PARAM[]

    set $param1 "";
    set $param2 "";
    set $param3 "";
    set $param4 "";
    set $param5 "";
    set $param6 "";
    set $param7 "";
    set $param8 "";
    set $param9 "";
    set $param10 "";
    set $param11 "";
    set $param12 "";

    if ($args ~ "PARAM\[\]=([^&]+)") {
        set $param1 ":PAR[]=$1";
    }
    if ($args ~ "PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+)") {
        set $param2 ":PAR[]=$2";
    }
    if ($args ~ "PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+)") {
        set $param3 ":PAR[]=$3";
    }
    if ($args ~ "PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+)") {
        set $param4 ":PAR[]=$4";
    }
    if ($args ~ "PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+)") {
        set $param5 ":PAR[]=$5";
    }
    if ($args ~ "PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+)") {
        set $param6 ":PAR[]=$6";
    }
    if ($args ~ "PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+)") {
        set $param7 ":PAR[]=$7";
    }
    if ($args ~ "PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+)") {
        set $param8 ":PAR[]=$8";
    }
    if ($args ~ "PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+)") {
        set $param9 ":PAR[]=$9";
    }
    if ($args ~ "PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+)") {
        set $param10 ":PAR[]=$10";
    }
    if ($args ~ "PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+)") {
        set $param11 ":PAR[]=$11";
    }
    if ($args ~ "PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+).*PARAM\[\]=([^&]+)") {
        set $param12 ":PAR[]=$12";
    }

# Construire l'URL finale
    set $final_params "${param_string}${param1}${param2}${param3}${param4}${param5}${param6}${param7}${param8}${param9}${param10}${param11}${param12}";

    rewrite ^/courses-lendemain/pronostics-courses\.html$ /pwa.php?type=LEND_STAT$final_params? permanent;
}
 
O
ortolojf
WRInaute accro
Excusez-moi

Si les suites de PARAM[]=1, etc... sont contigües et délimitées, il est possible de mettre de mette un caret ( ^ ) en début des regex, et des point d'interrogation ( ? ) en fin des regex pour les rendre non greedy.

Les PARAM sont isolés dans $beginofparams ( voir ci-dessus ).

Merci beaucoup.
 
O
ortolojf
WRInaute accro
Ouf.

Cà marche impec. ;)

Pas besoin de points d'interrogation.

En ajout au début des regex : ^&

Et puis, les PARAM sont séparés par des &.

C'est vai que c'est lourd, est-ce qu'il y aurait une implémentation récursive ?

Merci.




Code: 
# Utiliser la variable $args pour extraire tous les PARAM[]
if ($beginofparams ~ "^&PARAM\[\]=([^&]+)") {
set $param1 "PAR[]=$1";
}
if ($beginofparams ~ "^&PARAM\[\]=([^&]+)&PARAM\[\]=([^&]+)") {
set $param2 ":PAR[]=$2";
}
if ($beginofparams ~ "^&PARAM\[\]=([^&]+)&PARAM\[\]=([^&]+)&PARAM\[\]=([^&]+)") {
set $param3 ":PAR[]=$3";
}

... jusqu'à 12 PARAM[]
 
site-voyance
site-voyance
Nouveau WRInaute
# Solution pour extraire tous les PARAM[] de manière élégante
# À placer dans le bloc http ou server

# Déclaration des variables pour stocker les résultats
map $args $all_params {
default "";
# Expression régulière pour capturer tous les PARAM[]=value
"~(?:^|&)PARAM\[\]=([^&])(?:&|$).?(?:(?:^|&)PARAM\[\]=([^&])(?:&|$).?)?(?:(?:^|&)PARAM\[\]=([^&])(?:&|$).?)?(?:(?:^|&)PARAM\[\]=([^&])(?:&|$).?)?(?:(?:^|&)PARAM\[\]=([^&])(?:&|$).*?)?" $1:$2:$3:$4:$5;
}

server {
# [Vos autres configurations server...]

location /votre-endpoint {
# Initialisation du résultat final
set $param_result "";

# Extraction et formatage des paramètres
set_by_lua_block $formatted_params {
local params = ngx.var.all_params
local result = ""

if params and params ~= "" then
for param in string.gmatch(params, "[^:]+") do
if param and param ~= "" then
if result == "" then
result = "PAR[]=" .. param
else
result = result .. ":PAR[]=" .. param
end
end
end
end

return result
}

# Utilisation des paramètres formatés dans votre logique
# Exemple: proxy_pass ou autre traitement

# Pour déboguer:
add_header X-Debug-Params $formatted_params;
}
}

# Alternative sans Lua, mais limitée à un nombre fixe de paramètres
# Cette version est plus simple mais moins flexible

# Définir des variables pour chaque position possible
map $args $param1 {
"~(?:^|&)PARAM\[\]=([^&])(?:&|$)" $1;
default "";
}

map $args $param2 {
"~(?:^|&)PARAM\[\]=([^&])(?:&|$).?(?:^|&)PARAM\[\]=([^&])(?:&|$)" $2;
default "";
}

map $args $param3 {
"~(?:^|&)PARAM\[\]=([^&])(?:&|$).?(?:^|&)PARAM\[\]=([^&])(?:&|$).?(?:^|&)PARAM\[\]=([^&])(?:&|$)" $3;
default "";
}

# Et ainsi de suite pour autant de paramètres que nécessaire...

# Puis dans votre location:
location /autre-endpoint {
set $params "";

if ($param1 != "") {
set $params "PAR[]=$param1";
}

if ($param2 != "") {
set $params "$params:PAR[]=$param2";
}

if ($param3 != "") {
set $params "$params:PAR[]=$param3";
}

# Utilisation de $params dans votre logique
}
 
site-voyance
site-voyance
Nouveau WRInaute
  1. Solution avec Lua : C'est la plus élégante car elle permet vraiment de traiter un nombre variable de paramètres sans dupliquer le code. Elle utilise le module set_by_lua_block qui vous donne une flexibilité totale.
  2. Solution sans Lua : Une version améliorée de votre approche actuelle qui utilise des directives map pour extraire chaque position de paramètre séparément, ce qui reste plus propre que des if en cascade.

Les avantages de ces approches :


  • Code plus maintenable
  • Meilleure performance (surtout avec la directive map qui est évaluée une seule fois)
  • Plus facile à modifier si vos besoins changent

La solution avec Lua nécessite que le module ngx_http_lua_module soit installé dans votre NGINX. Si ce n'est pas le cas, la seconde approche reste bien meilleure que la série de conditions initiale.
 
O
ortolojf
WRInaute accro
Bonjour site voyance

Je n'ai pas la possibilité d'installer le module ngx_lua_module.

Merci beaucoup pour votre solution sans Lua.
 
Vous devez vous connecter ou vous inscrire pour répondre ici.

➡️ Offre MyRankingMetrics ⬅️

pré-audit SEO gratuit avec RM Tech (+ avis d'expert)
coaching offert aux clients (avec Olivier Duffez ou Fabien Faceries)

Voir les détails ici

coaching SEO
Discussions similaires
S
urlrewriting et refresh
Réponses
3
Affichages
1K
steph950
S
O
Paramètres urls & urlrewriting => alphabétiques ou codés ?
Réponses
3
Affichages
1K
ortolojf
O
N
Forcer l'utilisation de l'urlrewriting même si le dossier existe
Réponses
12
Affichages
2K
neo765
N
D
Question de béotien en urlrewriting
Réponses
6
Affichages
1K
dimeries12
D
A
problème urlrewriting
Réponses
3
Affichages
1K
ARcom
A
0
Problème dossier photo protégé + URLRewriting + ErrorDocument
Réponses
4
Affichages
2K
0takon
0
S
urlrewriting qui fonctionne en local mais pas en ligne
Réponses
3
Affichages
2K
sam01
S
D
J'ai du mal a écrire cette ligne de UrlRewriting
Réponses
11
Affichages
2K
Deus Ex Machina
D
W
Urlrewriting et paramètre
Réponses
7
Affichages
1K
forty
forty
P
Problème sur Urlrewriting et répertoire virtuel
Réponses
2
Affichages
2K
pisto255
P
M
Urlrewriting .htaccess, internal error 500
Réponses
9
Affichages
3K
Meeuuuhhh
M
A
urlrewriting et format unique
Réponses
13
Affichages
2K
Anonymous
A
S
probleme sur certain urlrewriting
Réponses
5
Affichages
1K
Vap
V
M
pb d'urlrewriting sur wampserver avec des alias
Réponses
4
Affichages
3K
gilles66
G
W
Urlrewriting et répertoires
Réponses
2
Affichages
2K
KOogar
KOogar
K
Probleme URLREWRITING et Ajax!
Réponses
2
Affichages
3K
klendrier
K
D
Probleme urlrewriting id + mots clés
Réponses
2
Affichages
2K
djohan
D
P
URLrewriting et plantage serveur
Réponses
5
Affichages
2K
papa
P
B
Utilisation d'un / dans l'urlrewriting
Réponses
3
Affichages
1K
braindead
B
T
Souci de redirection 301 via urlrewriting
Réponses
11
Affichages
2K
tyv
T
Haut