shlinkio · acelaya · Feb 29, 2024 · Feb 28, 2024 · Feb 29, 2024 · Feb 29, 2024
diff --git a/composer.json b/composer.json
@@ -19,6 +19,7 @@
         "ext-pdo": "*",
         "akrabat/ip-address-middleware": "^2.1",
         "cakephp/chronos": "^3.0.2",
+        "doctrine/dbal": "^4.0",
         "doctrine/migrations": "^3.6",
         "doctrine/orm": "^3.0",
         "endroid/qr-code": "^5.0",

diff --git a/config/autoload/mercure.local.php.dist b/config/autoload/mercure.local.php.dist
@@ -5,7 +5,7 @@ declare(strict_types=1);
 return [
 
     'mercure' => [
-        'public_hub_url' => 'http://localhost:8001',
+        'public_hub_url' => 'http://localhost:8002',
         'internal_hub_url' => 'http://shlink_mercure_proxy',
         'jwt_secret' => 'mercure_jwt_key_long_enough_to_avoid_error',
     ],

diff --git a/config/autoload/routes.config.php b/config/autoload/routes.config.php
@@ -46,6 +46,7 @@
 
                 //Redirect rules
                 Action\RedirectRule\ListRedirectRulesAction::getRouteDef([$dropDomainMiddleware]),
+                Action\RedirectRule\SetRedirectRulesAction::getRouteDef([$dropDomainMiddleware]),
 
                 // Short URLs
                 Action\ShortUrl\CreateShortUrlAction::getRouteDef([

diff --git a/docker-compose.yml b/docker-compose.yml
@@ -131,7 +131,7 @@ services:
         container_name: shlink_mercure_proxy
         image: nginx:1.25-alpine
         ports:
-            - "8001:80"
+            - "8002:80"
         volumes:
             - ./:/home/shlink/www
             - ./data/infra/mercure_proxy_vhost.conf:/etc/nginx/conf.d/default.conf

diff --git a/docs/swagger/definitions/ShortUrlRedirectRule.json b/docs/swagger/definitions/ShortUrlRedirectRule.json
@@ -15,12 +15,8 @@
       "type": "array",
       "items": {
         "type": "object",
-        "required": ["name", "type", "matchKey", "matchValue"],
+        "required": ["type", "matchKey", "matchValue"],
         "properties": {
-          "name":  {
-            "type": "string",
-            "description": "Unique condition name"
-          },
           "type": {
             "type": "string",
             "enum": ["device", "language", "query"],

diff --git a/docs/swagger/paths/v3_short-urls_{shortCode}_redirect-rules.json b/docs/swagger/paths/v3_short-urls_{shortCode}_redirect-rules.json
@@ -137,5 +137,164 @@
         }
       }
     }
+  },
+
+  "post": {
+    "operationId": "setShortUrlRedirectRules",
+    "tags": [
+      "Redirect rules"
+    ],
+    "summary": "Set short URL redirect rules",
+    "description": "Overwrites redirect rules for a short URL with the ones provided here.",
+    "parameters": [
+      {
+        "$ref": "../parameters/version.json"
+      },
+      {
+        "$ref": "../parameters/shortCode.json"
+      },
+      {
+        "$ref": "../parameters/domain.json"
+      }
+    ],
+    "security": [
+      {
+        "ApiKey": []
+      }
+    ],
+    "requestBody": {
+      "description": "Request body.",
+      "required": true,
+      "content": {
+        "application/json": {
+          "schema": {
+            "type": "object",
9E7A
+            "properties": {
+              "redirectRules": {
+                "type": "array",
+                "items": {
+                  "$ref": "../definitions/ShortUrlRedirectRule.json"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "responses": {
+      "200": {
+        "description": "The list of rules",
+        "content": {
+          "application/json": {
+            "schema": {
+              "type": "object",
+              "required": ["defaultLongUrl", "redirectRules"],
+              "properties": {
+                "defaultLongUrl": {
+                  "type": "string"
+                },
+                "redirectRules": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "../definitions/ShortUrlRedirectRule.json"
+                  }
+                }
+              }
+            },
+            "example": {
+              "defaultLongUrl": "https://example.com",
+              "redirectRules": [
+                {
+                  "longUrl": "https://example.com/android-en-us",
+                  "priority": 1,
+                  "conditions": [
+                    {
+                      "type": "device",
+                      "matchValue": "android",
+                      "matchKey": null
+                    },
+                    {
+                      "type": "language",
+                      "matchValue": "en-US",
+                      "matchKey": null
+                    }
+                  ]
+                },
+                {
+                  "longUrl": "https://example.com/fr",
+                  "priority": 2,
+                  "conditions": [
+                    {
+                      "type": "language",
+                      "matchValue": "fr",
+                      "matchKey": null
+                    }
+                  ]
+                },
+                {
+                  "longUrl": "https://example.com/query-foo-bar-hello-world",
+                  "priority": 3,
+                  "conditions": [
+                    {
+                      "type": "query",
+                      "matchKey": "foo",
+                      "matchValue": "bar"
+                    },
+                    {
+                      "type": "query",
+                      "matchKey": "hello",
+                      "matchValue": "world"
+                    }
+                  ]
+                }
+              ]
+            }
+          }
+        }
+      },
+      "404": {
+        "description": "No URL was found for provided short code.",
+        "content": {
+          "application/problem+json": {
+            "schema": {
+              "allOf": [
+                {
+                  "$ref": "../definitions/Error.json"
+                },
+                {
+                  "type": "object",
+                  "required": ["shortCode"],
+                  "properties": {
+                    "shortCode": {
+                      "type": "string",
+                      "description": "The short code with which we tried to find the short URL"
+                    },
+                    "domain": {
+                      "type": "string",
+                      "description": "The domain with which we tried to find the short URL"
+                    }
+                  }
+                }
+              ]
+            },
+            "examples": {
+              "Short URL not found": {
+                "$ref": "../examples/short-url-not-found-v3.json"
+              }
+            }
+          }
+        }
+      },
+      "default": {
+        "description": "Unexpected error.",
+        "content": {
+          "application/problem+json": {
+            "schema": {
+              "$ref": "../definitions/Error.json"
+            }
+          }
+        }
+      }
+    }
   }
 }
diff --git a/module/Core/src/RedirectRule/Entity/RedirectCondition.php b/module/Core/src/RedirectRule/Entity/RedirectCondition.php
@@ -7,6 +7,7 @@
 use Shlinkio\Shlink\Common\Entity\AbstractEntity;
 use Shlinkio\Shlink\Core\Model\DeviceType;
 use Shlinkio\Shlink\Core\RedirectRule\Model\RedirectConditionType;
+use Shlinkio\Shlink\Core\RedirectRule\Model\Validation\RedirectRulesInputFilter;
 
 use function Shlinkio\Shlink\Core\acceptLanguageToLocales;
 use function Shlinkio\Shlink\Core\ArrayUtils\some;
@@ -39,6 +40,15 @@ public static function forDevice(DeviceType $device): self
         return new self(RedirectConditionType::DEVICE, $device->value);
     }
 
+    public static function fromRawData(array $rawData): self
+    {
+        $type = RedirectConditionType::from($rawData[RedirectRulesInputFilter::CONDITION_TYPE]);
+        $value = $rawData[RedirectRulesInputFilter::CONDITION_MATCH_VALUE];
+        $key = $rawData[RedirectRulesInputFilter::CONDITION_MATCH_KEY] ?? null;
+
+        return new self($type, $value, $key);
+    }

     /**
      * Tells if this condition matches provided request
      */

diff --git a/module/Core/src/RedirectRule/Entity/ShortUrlRedirectRule.php b/module/Core/src/RedirectRule/Entity/ShortUrlRedirectRule.php
@@ -36,6 +36,11 @@ public function matchesRequest(ServerRequestInterface $request): bool
         );
     }
 
+    public function clearConditions(): void
+    {
+        $this->conditions->clear();
+    }
+
     public function jsonSerialize(): array
     {
         return [

diff --git a/module/Core/src/RedirectRule/Model/RedirectRulesData.php b/module/Core/src/RedirectRule/Model/RedirectRulesData.php
@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Shlinkio\Shlink\Core\RedirectRule\Model;
+
+use Laminas\InputFilter\Exception\InvalidArgumentException;
+use Shlinkio\Shlink\Core\Exception\ValidationException;
+use Shlinkio\Shlink\Core\RedirectRule\Model\Validation\RedirectRulesInputFilter;
+
+use function array_values;
+
+readonly class RedirectRulesData
+{
+    private function __construct(public array $rules)
+    {
+    }
+
+    public static function fromRawData(array $rawData): self
+    {
+        try {
+            $inputFilter = RedirectRulesInputFilter::initialize($rawData);
+            if (! $inputFilter->isValid()) {
+                throw ValidationException::fromInputFilter($inputFilter);
+            }
+
+            return new self(array_values($inputFilter->getValue(RedirectRulesInputFilter::REDIRECT_RULES)));
+        } catch (InvalidArgumentException) {
+            throw ValidationException::fromArray(
+                [RedirectRulesInputFilter::REDIRECT_RULES => RedirectRulesInputFilter::REDIRECT_RULES],
+            );
+        }
+    }
+}
diff --git a/module/Core/src/RedirectRule/Model/Validation/RedirectRulesInputFilter.php b/module/Core/src/RedirectRule/Model/Validation/RedirectRulesInputFilter.php
@@ -0,0 +1,89 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Shlinkio\Shlink\Core\RedirectRule\Model\Validation;
+
+use Laminas\InputFilter\CollectionInputFilter;
+use Laminas\InputFilter\InputFilter;
+use Laminas\Validator\Callback;
+use Laminas\Validator\InArray;
+use Shlinkio\Shlink\Common\Validation\InputFactory;
+use Shlinkio\Shlink\Core\Model\DeviceType;
+use Shlinkio\Shlink\Core\RedirectRule\Model\RedirectConditionType;
+use Shlinkio\Shlink\Core\ShortUrl\Model\Validation\ShortUrlInputFilter;
+
+use function Shlinkio\Shlink\Core\ArrayUtils\contains;
+use function Shlinkio\Shlink\Core\enumValues;
+
+class RedirectRulesInputFilter extends InputFilter
+{
+    public const REDIRECT_RULES = 'redirectRules';
+
+    public const RULE_LONG_URL = 'longUrl';
+    public const RULE_CONDITIONS = 'conditions';
+
+    public const CONDITION_TYPE = 'type';
+    public const CONDITION_MATCH_VALUE = 'matchValue';
+    public const CONDITION_MATCH_KEY = 'matchKey';
+
+    private function __construct()
+    {
+    }
+
+    public static function initialize(array $rawData): self
+    {
+        $redirectRulesInputFilter = new CollectionInputFilter();
+        $redirectRulesInputFilter->setInputFilter(self::createRedirectRuleInputFilter());
+
+        $instance = new self();
+        $instance->add($redirectRulesInputFilter, self::REDIRECT_RULES);
+
+        $instance->setData($rawData);
+        return $instance;
+    }
+
+    private static function createRedirectRuleInputFilter(): InputFilter
+    {
+        $redirectRuleInputFilter = new InputFilter();
+
+        $longUrl = InputFactory::basic(self::RULE_LONG_URL, required: true);
+        $longUrl->getValidatorChain()->merge(ShortUrlInputFilter::longUrlValidators());
+        $redirectRuleInputFilter->add($longUrl);
+
+        $conditionsInputFilter = new CollectionInputFilter();
+        $conditionsInputFilter->setInputFilter(self::createRedirectConditionInputFilter())
+                              ->setIsRequired(true);
+        $redirectRuleInputFilter->add($conditionsInputFilter, self::RULE_CONDITIONS);
+
+        return $redirectRuleInputFilter;
+    }
+
+    private static function createRedirectConditionInputFilter(): InputFilter
+    {
+        $redirectConditionInputFilter = new InputFilter();
+
+        $type = InputFactory::basic(self::CONDITION_TYPE, required: true);
+        $type->getValidatorChain()->attach(new InArray([
+            'haystack' => enumValues(RedirectConditionType::class),
+            'strict' => InArray::COMPARE_STRICT,
+        ]));
+        $redirectConditionInputFilter->add($type);
+
+        $value = InputFactory::basic(self::CONDITION_MATCH_VALUE, required: true);
+        $value->getValidatorChain()->attach(new Callback(function (string $value, array $context) {
+            if ($context[self::CONDITION_TYPE] === RedirectConditionType::DEVICE->value) {
+                return contains($value, enumValues(DeviceType::class));
+            }
+
+            return true;
+        }));
+        $redirectConditionInputFilter->add($value);
+
+        $redirectConditionInputFilter->add(
+            InputFactory::basic(self::CONDITION_MATCH_KEY, required: true)->setAllowEmpty(true),
+        );
+
+        return $redirectConditionInputFilter;
+    }
+}