.msg file upload

src/openforms/formio/api/validators.py

@@ -56,7 +56,8 @@ def __init__(self, allowed_mime_types: Iterable[str] | None = None):
 
     def __call__(self, value: UploadedFile) -> None:
         head = value.read(2048)
-        ext = value.name.split(".")[-1]
+        file_name_parts = value.name.split(".")
+        ext = file_name_parts[-1]
         mime_type = magic.from_buffer(head, mime=True)
 
         # gh #2520
@@ -76,6 +77,14 @@ def __call__(self, value: UploadedFile) -> None:
                 _("The provided file is not a valid file type.")
             )
 
+        if len(file_name_parts) == 1:
+            raise serializers.ValidationError(
+                _(
+                    "Could not determine the file type. Please make sure the file name "
+                    "has an extension."
+                )
+            )
+
         # Contents is allowed. Do extension or submitted content_type agree?
         if value.content_type == "application/octet-stream":
             m = magic.Magic(extension=True)
@@ -111,6 +120,11 @@ def __call__(self, value: UploadedFile) -> None:
             "image/heif",
         ):
             return
+        # 4795
+        # The sdk cannot determine the file type of .msg files, which result into
+        # content_type "". So we have to validate these for ourselves
+        elif mime_type == "application/vnd.ms-outlook" and ext == "msg":
+            return
 
         # gh #4658
         # Windows use application/x-zip-compressed as a mimetype for .zip files, which

src/openforms/formio/components/vanilla.py

@@ -338,14 +338,7 @@ class FileSerializer(serializers.Serializer):
     originalName = serializers.CharField(trim_whitespace=False)
     size = serializers.IntegerField(min_value=0)
     storage = serializers.ChoiceField(choices=["url"])
-    type = serializers.CharField(
-        error_messages={
-            "blank": _(
-                "Could not determine the file type. Please make sure the file name "
-                "has an extension."
-            ),
-        }
-    )
+    type = serializers.CharField(required=False, allow_blank=True)
     url = serializers.URLField()
     data = FileDataSerializer()  # type: ignore
 

src/openforms/formio/tests/test_validators.py

@@ -202,6 +202,22 @@ def test_allowed_mime_types_for_csv_files(self):
 
             validator(sample)
 
+    def test_allowed_mime_types_for_msg_files(self):
+        valid_type = "application/vnd.ms-outlook"
+        msg_file = TEST_FILES / "test.msg"
+        validator = validators.MimeTypeValidator(allowed_mime_types=[valid_type])
+
+        # 4795
+        # The sdk cannot determine the content_type for .msg files correctly.
+        # Because .msg is a windows specific file, and linux and MacOS don't know it.
+        # So we simulate the scenario where content_type is unknown
+        sample = SimpleUploadedFile(
+            "test.msg",
+            msg_file.read_bytes(),
+        )
+
+        validator(sample)
+
     def test_validate_files_multiple_mime_types(self):
         """Assert that validation of files associated with multiple mime types works
 

src/openforms/formio/tests/validation/test_file.py

@@ -602,10 +602,10 @@ def test_attach_upload_validates_unknown_file_type(self):
         }
 
         is_valid, errors = validate_formio_data(component, data, submission=submission)
-        error = extract_error(errors["foo"][0], "type")
+        error = extract_error(errors["foo"][0], "non_field_errors")
 
         self.assertFalse(is_valid)
-        self.assertEqual(error.code, "blank")
+        self.assertEqual(error.code, "invalid")
         self.assertEqual(
             error,
             _(

src/openforms/tests/e2e/test_file_upload.py

@@ -77,3 +77,64 @@ def setUpTestData():
                 await expect(
                     page.get_by_text("Een moment geduld", exact=False)
                 ).to_be_visible()
+
+    async def test_form_with_msg_file_upload(self):
+        # If using the ci.py settings locally, the SDK_RELEASE  variable should be set to 'latest', otherwise the
+        # JS/CSS for the SDK will not be found (since they will be expected to be in the folder
+        # openforms/static/sdk/<SDK version tag> instead of openforms/static/sdk
+        @sync_to_async
+        def setUpTestData():
+            # set up a form
+            form = FormFactory.create(
+                name="Form with file upload",
+                slug="form-with-file-upload",
+                generate_minimal_setup=True,
+                formstep__form_definition__name="First step",
+                formstep__form_definition__slug="first-step",
+                formstep__form_definition__configuration={
+                    "components": [
+                        {
+                            "type": "file",
+                            "key": "fileUpload",
+                            "label": "File Upload",
+                            "storage": "url",
+                            "validate": {
+                                "required": True,
+                            },
+                        }
+                    ]
+                },
+                translation_enabled=False,  # force Dutch
+                ask_privacy_consent=False,
+                ask_statement_of_truth=False,
+            )
+            return form
+
+        form = await setUpTestData()
+        form_url = str(
+            furl(self.live_server_url)
+            / reverse("forms:form-detail", kwargs={"slug": form.slug})
+        )
+
+        with patch("openforms.utils.validators.allow_redirect_url", return_value=True):
+            async with browser_page() as page:
+                await page.goto(form_url)
+
+                await page.get_by_role("button", name="Formulier starten").click()
+
+                async with page.expect_file_chooser() as fc_info:
+                    await page.get_by_text("blader").click()
+
+                file_chooser = await fc_info.value
+                await file_chooser.set_files(TEST_FILES / "test.msg")
+
+                await page.wait_for_load_state("networkidle")
+
+                uploaded_file = page.get_by_role("link", name="test.msg")
+                await expect(uploaded_file).to_be_visible()
+
+                await page.get_by_role("button", name="Volgende").click()
+                await page.get_by_role("button", name="Verzenden").click()
+                await expect(
+                    page.get_by_text("Een moment geduld", exact=False)
+                ).to_be_visible()

src/openforms/tests/e2e/test_input_validation.py

@@ -940,7 +940,7 @@ def test_unknown_file_type(self):
         # The frontend validation will *not* create a TemporaryFileUpload,
         # as the frontend will block the upload because of the invalid file type.
         # However the user could do an handcrafted API call.
-        # For this reason, we manually create an invalid TemporaryFileUpload
+        # For this reason, we manually try to create an invalid TemporaryFileUpload
         # and use it for the `api_value`:
 
         with open(TEST_FILES / "unknown-type", "rb") as infile:
@@ -966,8 +966,8 @@ def test_unknown_file_type(self):
                 ],
             )
 
-        # Make sure the frontend did not create one:
-        self.assertEqual(TemporaryFileUpload.objects.count(), 1)
+        # Make sure that no temporary files were created
+        self.assertEqual(TemporaryFileUpload.objects.count(), 0)
 
 
 class SingleAddressNLTests(ValidationsTestCase):