feat(pci-load-balancer): add rule form and create page

packages/manager/apps/pci-load-balancer/public/translations/l7/rules/create/Messages_de_DE.json

@@ -0,0 +1,3 @@
+{
+  "octavia_load_balancer_create_l7_rule_submit_creation": "Hinzufügen"
+}

packages/manager/apps/pci-load-balancer/public/translations/l7/rules/create/Messages_en_GB.json

@@ -0,0 +1,3 @@
+{
+  "octavia_load_balancer_create_l7_rule_submit_creation": "Add"
+}

packages/manager/apps/pci-load-balancer/public/translations/l7/rules/create/Messages_es_ES.json

@@ -0,0 +1,3 @@
+{
+  "octavia_load_balancer_create_l7_rule_submit_creation": "Añadir"
+}

packages/manager/apps/pci-load-balancer/public/translations/l7/rules/create/Messages_fr_CA.json

@@ -0,0 +1,3 @@
+{
+  "octavia_load_balancer_create_l7_rule_submit_creation": "Ajouter"
+}

packages/manager/apps/pci-load-balancer/public/translations/l7/rules/create/Messages_fr_FR.json

@@ -0,0 +1,3 @@
+{
+  "octavia_load_balancer_create_l7_rule_submit_creation": "Ajouter"
+}

packages/manager/apps/pci-load-balancer/public/translations/l7/rules/create/Messages_it_IT.json

@@ -0,0 +1,3 @@
+{
+  "octavia_load_balancer_create_l7_rule_submit_creation": "Aggiungi"
+}

packages/manager/apps/pci-load-balancer/public/translations/l7/rules/create/Messages_pl_PL.json

@@ -0,0 +1,3 @@
+{
+  "octavia_load_balancer_create_l7_rule_submit_creation": "Dodaj"
+}

packages/manager/apps/pci-load-balancer/public/translations/l7/rules/create/Messages_pt_PT.json

@@ -0,0 +1,3 @@
+{
+  "octavia_load_balancer_create_l7_rule_submit_creation": "Adicionar"
+}

packages/manager/apps/pci-load-balancer/public/translations/l7/rules/rules-form/Messages_de_DE.json

@@ -0,0 +1,32 @@
+{
+  "octavia_load_balancer_create_l7_rule_type": "Typ",
+  "octavia_load_balancer_create_l7_rule_type_default": "Einen Typ für die L7 Rule auswählen",
+  "octavia_load_balancer_create_l7_rule_type_cookie": "Die L7 Rule sucht nach dem Wert des Cookies, der ihrem Schlüssel entspricht, und vergleicht seinen Wert mit dem Wert der Regel.",
+  "octavia_load_balancer_create_l7_rule_type_fileType": "Die Regel vergleicht den letzten Teil des URI mit dem Wertparameter der Regel (z. B. „TXT“, „JPG“ usw.)",
+  "octavia_load_balancer_create_l7_rule_type_header": "Die Regel sucht nach einem Header, der im Schlüsselparameter definiert ist, und vergleicht ihn mit dem Wertparameter der Regel.",
+  "octavia_load_balancer_create_l7_rule_type_hostName": "Die Regel vergleicht den HTTP/1.1-Hostnamen der Anforderung mit dem Wertparameter der Regel.",
+  "octavia_load_balancer_create_l7_rule_type_path": "Die Regel vergleicht den Pfadteil des HTTP-URI mit dem Wertparameter der Regel.",
+  "octavia_load_balancer_create_l7_rule_type_sslConnHasCert": "Die Regel stimmt überein, wenn der Client ein Zertifikat für die TLS-Clientauthentifizierung vorgelegt hat. Dies bedeutet nicht, dass das Zertifikat gültig ist.",
+  "octavia_load_balancer_create_l7_rule_type_sslVerifyResult": "Diese Regel entspricht dem Überprüfungsergebnis des Zertifikats für die TLS-Clientauthentifizierung.",
+  "octavia_load_balancer_create_l7_rule_type_sslDNField": "Die Regel sucht nach einem Feld Eindeutiger Name, das im Schlüsselparameter definiert ist, und vergleicht es mit dem Wertparameter der Regel.",
+  "octavia_load_balancer_create_l7_rule_compare_type": "Vergleichstyp",
+  "octavia_load_balancer_create_l7_rule_compare_type_default": "Vergleichstyp auswählen",
+  "octavia_load_balancer_create_l7_rule_compare_type_regex": "Übereinstimmung mit regulären Ausdrücken vom Typ Perl.",
+  "octavia_load_balancer_create_l7_rule_compare_type_startsWith": "Die Zeichenfolge beginnt mit.",
+  "octavia_load_balancer_create_l7_rule_compare_type_endsWith": "Die Zeichenfolge endet mit.",
+  "octavia_load_balancer_create_l7_rule_compare_type_contains": "Die Zeichenfolge enthält.",
+  "octavia_load_balancer_create_l7_rule_compare_type_equalTo": "Die Zeichenfolge ist gleich.",
+  "octavia_load_balancer_create_l7_rule_key": "Schlüssel",
+  "octavia_load_balancer_create_l7_rule_key_tooltip": "Der für den Vergleich zu verwendende Schlüssel. Beispielsweise der Name des auszuwertenden Cookies.",
+  "octavia_load_balancer_create_l7_rule_key_pattern": "Der Schlüssel darf nur aus alphanumerischen Zeichen und den folgenden Zeichen bestehen: „!“, „#“, „$“, „%“, „&“, „'“ „*“, „+“, „-“, „.“, „^“, „_“, „`“, „|“, „~“.",
+  "octavia_load_balancer_create_l7_rule_value": "Wert",
+  "octavia_load_balancer_create_l7_rule_value_tooltip": "Der vom Vergleichstyp verwendete Wert. Zum Beispiel der Typ, der zu vergleichenden Datei.",
+  "octavia_load_balancer_create_l7_rule_value_regex_pattern": "Der angegebene Wert ist kein gültiger regulärer Ausdruck.",
+  "octavia_load_balancer_create_l7_rule_value_ssl_verify_result_pattern": "Für eine L7 Rule vom Typ „SSL verify result“ muss der Wert eine ganze Zahl größer oder gleich 0 sein.",
+  "octavia_load_balancer_create_l7_rule_value_cookie_pattern": "Bei einer L7 Rule vom Typ „Cookie“ darf der Wert nur aus alphanumerischen Zeichen und den folgenden Zeichen bestehen: „!“, „#“, „$“, „%“, „&“, „'“, „(“, „)“, „*“, „+“, „-“, „.“, „/“, „:“, „<“, „=“, „>“, „?“, „@“, „[“, „]“, „^“, „_“, „`“, „{“, „|“, „}“, „~“.",
+  "octavia_load_balancer_create_l7_rule_value_default_pattern": "Der Wert darf nur aus alphanumerischen Zeichen und den folgenden Zeichen bestehen: „!“, „\"“, „#“, „$“, „%“, „&“, „'“, „(“, „)“, „*“, „+“, „,“, „-“, „.“, „/“, „:“, „;“, „<“, „=“, „>“, „?“, „@“, „[“, „]“, „^“, „_“, „`“, „{“, „|“, „}“, „~“, „\\“.",
+  "octavia_load_balancer_create_l7_rule_invert": "Umkehren",
+  "octavia_load_balancer_create_l7_rule_invert_tooltip": "Wenn der Werk „True“ lautet, wird die Logik der Regel umgekehrt.",
+  "octavia_load_balancer_create_l7_rule_submit": "Bearbeiten",
+  "octavia_load_balancer_create_l7_rule_cancel": "Abbrechen"
+}

packages/manager/apps/pci-load-balancer/public/translations/l7/rules/rules-form/Messages_en_GB.json

@@ -0,0 +1,32 @@
+{
+  "octavia_load_balancer_create_l7_rule_type": "Type",
+  "octavia_load_balancer_create_l7_rule_type_default": "Select an L7 rule type",
+  "octavia_load_balancer_create_l7_rule_type_cookie": "The L7 rule searches for the cookie value equal to its key and compares its value to the rule value.",
+  "octavia_load_balancer_create_l7_rule_type_fileType": "The rule compares the last part of the URI with the value parameter of the rule (e.g. “txt”, “jpg”, etc.).",
+  "octavia_load_balancer_create_l7_rule_type_header": "The rule searches for a header defined in the key parameter and compares it to the value parameter of the rule.",
+  "octavia_load_balancer_create_l7_rule_type_hostName": "The rule compares the HTTP/1.1 hostname of the request with the value parameter of the rule.",
+  "octavia_load_balancer_create_l7_rule_type_path": "The rule compares the path portion of the HTTP URI with the value parameter of the rule.",
+  "octavia_load_balancer_create_l7_rule_type_sslConnHasCert": "The rule matches if the client has presented a certificate for TLS client authentication. This does not mean that the certificate is valid.",
+  "octavia_load_balancer_create_l7_rule_type_sslVerifyResult": "This rule will match the validation result of the TLS client authentication certificate.",
+  "octavia_load_balancer_create_l7_rule_type_sslDNField": "The rule searches for a Unique Name field defined in the key parameter and compares it to the value parameter of the rule.",
+  "octavia_load_balancer_create_l7_rule_compare_type": "Comparison type",
+  "octavia_load_balancer_create_l7_rule_compare_type_default": "Choose a comparison type",
+  "octavia_load_balancer_create_l7_rule_compare_type_regex": "Perl regular expression matching.",
+  "octavia_load_balancer_create_l7_rule_compare_type_startsWith": "String starts with.",
+  "octavia_load_balancer_create_l7_rule_compare_type_endsWith": "String ends with.",
+  "octavia_load_balancer_create_l7_rule_compare_type_contains": "String contains.",
+  "octavia_load_balancer_create_l7_rule_compare_type_equalTo": "String is equal to.",
+  "octavia_load_balancer_create_l7_rule_key": "Key",
+  "octavia_load_balancer_create_l7_rule_key_tooltip": "The key to use for the comparison. For example, the name of the cookie to evaluate.",
+  "octavia_load_balancer_create_l7_rule_key_pattern": "The key can only be composed of alphanumeric characters and the following characters: !#$%&'*+-.^_`|~",
+  "octavia_load_balancer_create_l7_rule_value": "Value",
+  "octavia_load_balancer_create_l7_rule_value_tooltip": "The value used by the comparison type. For example, the type of file to compare.",
+  "octavia_load_balancer_create_l7_rule_value_regex_pattern": "The value entered is not a valid regular expression.",
+  "octavia_load_balancer_create_l7_rule_value_ssl_verify_result_pattern": "For an ‘SSL verify result’ type L7 rule, the value must be an integer greater than or equal to 0.",
+  "octavia_load_balancer_create_l7_rule_value_cookie_pattern": "For a ‘Cookie’ type L7 rule, the value can only be composed of alphanumeric characters and the following characters: !#$%&'()*+-./:<=>?@[]^_`{|}~",
+  "octavia_load_balancer_create_l7_rule_value_default_pattern": "The value can only contain alphanumeric characters and the following characters: !\"#$%&'()*+,-./:;<=>?@[]^_`{|}~\\\\",
+  "octavia_load_balancer_create_l7_rule_invert": "Reverse",
+  "octavia_load_balancer_create_l7_rule_invert_tooltip": "When set to “true”, the rule logic is reversed.",
+  "octavia_load_balancer_create_l7_rule_submit": "Edit",
+  "octavia_load_balancer_create_l7_rule_cancel": "Cancel"
+}

packages/manager/apps/pci-load-balancer/public/translations/l7/rules/rules-form/Messages_es_ES.json

@@ -0,0 +1,32 @@
+{
+  "octavia_load_balancer_create_l7_rule_type": "Tipo",
+  "octavia_load_balancer_create_l7_rule_type_default": "Seleccionar un tipo de L7 rule",
+  "octavia_load_balancer_create_l7_rule_type_cookie": "La L7 rule busca el valor de la cookie igual a su clave y compara su valor con el valor de la regla.",
+  "octavia_load_balancer_create_l7_rule_type_fileType": "La regla compara la última parte del URI con el parámetro de valor de la regla. (por ejemplo, \"txt\", \"jpg\", etc.)",
+  "octavia_load_balancer_create_l7_rule_type_header": "La regla busca un encabezado definido en el parámetro clave y lo compara con el parámetro de valor de la regla.",
+  "octavia_load_balancer_create_l7_rule_type_hostName": "La regla compara el nombre de host HTTP/1.1 de la solicitud con el parámetro de valor de la regla.",
+  "octavia_load_balancer_create_l7_rule_type_path": "La regla compara la parte de ruta del URI HTTP con el parámetro de valor de la regla.",
+  "octavia_load_balancer_create_l7_rule_type_sslConnHasCert": "La regla coincide si el cliente presentó un certificado para la autenticación del cliente TLS. Esto no significa que el certificado sea válido.",
+  "octavia_load_balancer_create_l7_rule_type_sslVerifyResult": "Esta regla coincidirá con el resultado de la validación del certificado de autenticación del cliente TLS.",
+  "octavia_load_balancer_create_l7_rule_type_sslDNField": "La regla busca un campo de nombre único definido en el parámetro clave y lo compara con el parámetro valor de la regla.",
+  "octavia_load_balancer_create_l7_rule_compare_type": "Tipo de comparación",
+  "octavia_load_balancer_create_l7_rule_compare_type_default": "Elegir un tipo de comparación",
+  "octavia_load_balancer_create_l7_rule_compare_type_regex": "Coincidencia de expresiones regulares de tipo Perl.",
+  "octavia_load_balancer_create_l7_rule_compare_type_startsWith": "La cadena empieza por.",
+  "octavia_load_balancer_create_l7_rule_compare_type_endsWith": "La cadena termina en.",
+  "octavia_load_balancer_create_l7_rule_compare_type_contains": "La cadena contiene.",
+  "octavia_load_balancer_create_l7_rule_compare_type_equalTo": "La cadena es igual a.",
+  "octavia_load_balancer_create_l7_rule_key": "Clave",
+  "octavia_load_balancer_create_l7_rule_key_tooltip": "La clave que se va a utilizar para la comparación. Por ejemplo, el nombre de la cookie que se va a evaluar.",
+  "octavia_load_balancer_create_l7_rule_key_pattern": "La clave solo puede contener caracteres alfanuméricos y los siguientes caracteres: \"!\", \"#\", \"$\", \"%\", \"&\", \"'\", \"*\", \"+\", \"-\", \".\", \"^\", \"_\", \"`\", \"|\", \"~\".",
+  "octavia_load_balancer_create_l7_rule_value": "Valor",
+  "octavia_load_balancer_create_l7_rule_value_tooltip": "Valor utilizado por el tipo de comparación. Por ejemplo, el tipo de archivo que se va a comparar.",
+  "octavia_load_balancer_create_l7_rule_value_regex_pattern": "El valor introducido no es una expresión regular válida.",
+  "octavia_load_balancer_create_l7_rule_value_ssl_verify_result_pattern": "Para una L7 rule de tipo 'SSL verify result', el valor debe ser un entero mayor o igual que 0.",
+  "octavia_load_balancer_create_l7_rule_value_cookie_pattern": "Para una L7 rule de tipo 'Cookie', el valor solo puede estar compuesto por caracteres alfanuméricos y los siguientes caracteres: \"!\", \"#\", \"$\", \"%\", \"&\", \"'\", \"(\", \")\", \"*\", \"+\", \"-\", \".\", \"/\", \":\", \"<\", \"=\", \">\", \"?\", \"@\", \"[\", \"]\", \"^\", \"_\", \"`\", \"{\", \"|\", \"}\", \"~\".",
+  "octavia_load_balancer_create_l7_rule_value_default_pattern": "El valor solo puede contener caracteres alfanuméricos y los siguientes caracteres: \"!\", \"\", \"#\", \"$\", \"%\", \"&\", \"'\", \"(\", \"*\", \"+\", \",\", \"-\", \".\", \"/\", \":\", \";\", \"<\", \"=\", \">\", \"?\", \"@\", \"[\", \"]\", \"^\", \"_\", \"`\", \"{\", \"|\", \"}\", \"~\", \"\\\".",
+  "octavia_load_balancer_create_l7_rule_invert": "Invertir",
+  "octavia_load_balancer_create_l7_rule_invert_tooltip": "Cuando el valor es \"True\", se invierte la lógica de la regla.",
+  "octavia_load_balancer_create_l7_rule_submit": "Editar",
+  "octavia_load_balancer_create_l7_rule_cancel": "Cancelar"
+}

packages/manager/apps/pci-load-balancer/public/translations/l7/rules/rules-form/Messages_fr_CA.json

@@ -0,0 +1,32 @@
+{
+  "octavia_load_balancer_create_l7_rule_type": "Type",
+  "octavia_load_balancer_create_l7_rule_type_default": "Sélectionner un type de L7 rule",
+  "octavia_load_balancer_create_l7_rule_type_cookie": "La L7 rule recherche la valeur du cookie égale à sa clé et compare sa valeur à la valeur de la règle.",
+  "octavia_load_balancer_create_l7_rule_type_fileType": "La règle compare la dernière partie de l'URI au paramètre de valeur de la règle. (par exemple, \"txt\", \"jpg\", etc.)",
+  "octavia_load_balancer_create_l7_rule_type_header": "La règle recherche un en-tête défini dans le paramètre clé et le compare au paramètre de valeur de la règle.",
+  "octavia_load_balancer_create_l7_rule_type_hostName": "La règle compare le nom d'hôte HTTP/1.1 de la requête au paramètre de valeur de la règle.",
+  "octavia_load_balancer_create_l7_rule_type_path": "La règle compare la partie chemin de l'URI HTTP au paramètre de valeur de la règle.",
+  "octavia_load_balancer_create_l7_rule_type_sslConnHasCert": "La règle correspond si le client a présenté un certificat pour l'authentification du client TLS. Cela ne signifie pas que le certificat est valide.",
+  "octavia_load_balancer_create_l7_rule_type_sslVerifyResult": "Cette règle correspondra au résultat de validation du certificat d'authentification du client TLS.",
+  "octavia_load_balancer_create_l7_rule_type_sslDNField": "La règle recherche un champ Nom unique défini dans le paramètre clé et le compare au paramètre valeur de la règle.",
+  "octavia_load_balancer_create_l7_rule_compare_type": "Type de comparaison",
+  "octavia_load_balancer_create_l7_rule_compare_type_default": "Choisir un type de comparaison",
+  "octavia_load_balancer_create_l7_rule_compare_type_regex": "Correspondance d'expressions régulières de type Perl.",
+  "octavia_load_balancer_create_l7_rule_compare_type_startsWith": "La chaîne commence par.",
+  "octavia_load_balancer_create_l7_rule_compare_type_endsWith": "La chaîne se termine par.",
+  "octavia_load_balancer_create_l7_rule_compare_type_contains": "La chaîne contient.",
+  "octavia_load_balancer_create_l7_rule_compare_type_equalTo": "La chaîne est égale à.",
+  "octavia_load_balancer_create_l7_rule_key": "Clé",
+  "octavia_load_balancer_create_l7_rule_key_tooltip": "La clé à utiliser pour la comparaison. Par exemple, le nom du cookie à évaluer.",
+  "octavia_load_balancer_create_l7_rule_key_pattern": "La clé ne peut être composée que de caractères alphanumériques et des caractères suivants: \"!\", \"#\", \"$\", \"%\", \"&\", \"'\", \"*\", \"+\", \"-\", \".\", \"^\", \"_\", \"`\", \"|\", \"~\".",
+  "octavia_load_balancer_create_l7_rule_value": "Valeur",
+  "octavia_load_balancer_create_l7_rule_value_tooltip": "La valeur utilisée par le type de comparaison. Par exemple, le type de fichier à comparer.",
+  "octavia_load_balancer_create_l7_rule_value_regex_pattern": "La valeur saisie n'est pas une expression régulière valide.",
+  "octavia_load_balancer_create_l7_rule_value_ssl_verify_result_pattern": "Pour une L7 rule de type 'SSL verify result', la valeur doit être un entier supérieur ou égal à 0.",
+  "octavia_load_balancer_create_l7_rule_value_cookie_pattern": "Pour une L7 rule de type 'Cookie', la valeur ne peut être composée que de caractères alphanumériques et des caractères suivants: \"!\", \"#\", \"$\", \"%\", \"&\", \"'\", \"(\", \")\", \"*\", \"+\", \"-\", \".\", \"/\", \":\", \"<\", \"=\", \">\", \"?\", \"@\", \"[\", \"]\", \"^\", \"_\", \"`\", \"{\", \"|\", \"}\", \"~\".",
+  "octavia_load_balancer_create_l7_rule_value_default_pattern": "La valeur ne peut être composée que de caractères alphanumériques et des caractères suivants: \"!\", \"\"\", \"#\", \"$\", \"%\", \"&\", \"'\", \"(\", \")\", \"*\", \"+\", \",\", \"-\", \".\", \"/\", \":\", \";\", \"<\", \"=\", \">\", \"?\", \"@\", \"[\", \"]\", \"^\", \"_\", \"`\", \"{\", \"|\", \"}\", \"~\", \"\\\".",
+  "octavia_load_balancer_create_l7_rule_invert": "Inverser",
+  "octavia_load_balancer_create_l7_rule_invert_tooltip": "Quand la valeur est \"True\", la logique de la règle est inversée.",
+  "octavia_load_balancer_create_l7_rule_submit": "Editer",
+  "octavia_load_balancer_create_l7_rule_cancel": "Annuler"
+}