Release

contracts/management/commands/import_old_contracts.py

@@ -2,15 +2,31 @@ import io
 import os
 import re
 import string
+import shutil
 from datetime import date, datetime
 
 import yaml
 from django.conf import settings
+from django.core.files import File
 from django.core.management.base import BaseCommand
+from django.db import models
+from postal.parser import parse_address
 
 from git import Repo
 
-from ...models import Contract, ContractFilingArea, ContractType
+from ...models import (
+    Contract,
+    Contractee,
+    ContracteeSignature,
+    ContracteeSignatureRepresentative,
+    ContractFile,
+    ContractFilingArea,
+    ContractIssue,
+    ContractType,
+    Signee,
+    SigneeSignature,
+    SigneeSignatureRepresentative,
+)
 
 
 class Command(BaseCommand):
@@ -22,10 +38,11 @@ class Command(BaseCommand):
         self.normal_import_count = 0
         self.partial_import_count = 0
         self.already_imported_count = 0
+        self.normalization_count = 0
         self.issue_count = 0
         self.fatal_error_count = 0
 
-    def add_arguments(self, parser):
+    def add_arguments(self, parser) -> None:
         parser.add_argument(
             "repo_url",
             type=str,
@@ -41,6 +58,11 @@ class Command(BaseCommand):
             type=str,
             help="Directory to store the cloned repository in",
         )
+        parser.add_argument(
+            "--delete",
+            action="store_true",
+            help="Delete the old temporary storage directory, if it exists.",
+        )
         parser.add_argument(
             "--existing",
             action="store_true",
@@ -52,10 +74,19 @@ class Command(BaseCommand):
             help="Purge all previous contracts, types and filing areas before the import.",
         )
 
+    def use_issue(self, contract, name: str) -> None:
+        try:
+            issue = ContractIssue.objects.get(name=name)
+        except ContractIssue.DoesNotExist:
+            issue = ContractIssue(name=name)
+
+        return issue
+
     def normalize_type(self, type_name: str) -> str:
         type_name = string.capwords(type_name)
 
         patterns = (
+            (r"\s\s+", " "),
             (r" O ", " o "),
             (r" S ", " s "),
             (r" K ", " k "),
@@ -127,10 +158,74 @@ class Command(BaseCommand):
 
         return type_name
 
+    def normalize_department(self, type_name: str) -> str:
+        type_name = type_name.strip()
+
+        patterns = (
+            (r"\s\s+", " "),
+            (r"^Kraské sdružení Praha$", "Krajské sdružení Praha"),
+            (r"^republikové předsednictvo$", "Republikové předsednictvo"),
+            (r"^KS ", "Krajské sdružení "),
+            (r"^(MS |místní sdružení )", "Místní sdružení "),
+            (r"^(Ústecký kraj|Ustecký kraj)$", "Krajské sdružení Ústecký kraj"),
+            (
+                r"^Moravskoslezský kraj$",
+                "Krajské sdružení Moravskoslezský kraj",
+            ),
+            (
+                r"^Karlovarský kraj$",
+                "Krajské sdružení Karlovarský kraj",
+            ),
+            (
+                r"Jihočeská kraj",
+                "Jihočeský kraj",
+            ),
+            (r"^(Krajského |krajské |Kajské )", "Krajské "),
+            ("^Poslanecký klub České pirátské strany$", "Poslanecký klub"),
+            (r"Středočeký", "Středočeský"),
+            (r"^Zahraničního odboru$", "Zahraniční odbor"),
+            (r"JčK", "Jihočeský kraj"),
+            (r"SčK", "Středočeský kraj"),
+            (r"(ÚsK|UsK)", "Ústecký kraj"),
+            (r"JmK", "Jihomoravský kraj"),
+            (r"PaK", "Pardubický kraj"),
+            (r"KhK", "Královehradecký kraj"),
+            (r"(Prsonální|personální)", "Personální"),
+            (r"^administrativní ", "Administrativní "),
+            (r"technický", "Technický"),
+            (r"Mediálni", "Technický"),
+            (r"^řešitel ", "Řešitel "),
+            (r"^předsednictvo ", "Předsednictvo "),
+            (r"olomoucký", "Olomoucký"),
+            (r"^místní ", "Místní "),
+            (r"^celostátní ", "Celostátní "),
+            (r"odbor", "Odbor"),
+            (r"PKS", "Předsednictvo krajského sdružení"),
+            (r"( KS | Krajského sdružení )", " krajského sdružení "),
+            (
+                r"^(Předsednictvo krajského sdružení |Předsednictvo |Místní předsednictvo )",
+                "",
+            ),
+            (r"^Krajské předsednictvo ", "Krajské sdružení "),
+            (r"ého kraje$", "ý kraj"),
+            (r"^Olomouc$", "Místní sdružení Olomouc"),
+            (r"^Olomoucký kraj$", "Krajské sdružení Olomoucký kraj"),
+            (r"^Pardubický kraj$", "Krajské sdružení Pardubický kraj"),
+            (r"^Jihočeský kraj$", "Krajské sdružení Jihočeský kraj"),
+            (r"^Královehradecký kraj$", "Krajské sdružení Královehradecký kraj"),
+            (r"^Pardubický kraj$", "Krajské sdružení Pardubický kraj"),
+        )
+
+        for pattern in patterns:
+            type_name = re.sub(pattern[0], pattern[1], type_name)
+
+        return type_name
+
     def normalize_filing_area(self, area_name: str) -> str:
         area_name = string.capwords(area_name)
 
         patterns = (
+            (r"\s\s+", " "),
             (
                 r"^(Cenrální Spisovna|Censtrální Spisovna|Centrála|Centrálách Archiv Str"
                 r"any|Centrála Strany|Centrální Achiv Strany|Centrální Archiv|Centralni "
@@ -216,6 +311,24 @@ class Command(BaseCommand):
 
         return area_name
 
+    def normalize_filename(self, filename: str) -> str:
+        filename = string.capwords(filename)
+
+        patterns = (
+            (r"\s\s+", " "),
+            (
+                r"^((P|p)odepsaná (V|v)erze|Strojově Čitelná Verze)$",
+                "Anonymizovaná verze",
+            ),
+            (r"^(P|p)odepsaná (V|v)erze 2$", "Anonymizovaná verze 2"),
+            (r"^(U|u)pravitelná (V|v)erze$", "Upravitelná verze"),
+        )
+
+        for pattern in patterns:
+            filename = re.sub(pattern[0], pattern[1], filename)
+
+        return filename
+
     def parse_index(
         self,
         contract_root: str,
@@ -235,6 +348,7 @@ class Command(BaseCommand):
             .replace("-32", "-31")
             .replace("\t", " ")
         )
+        self.normalization_count += 1
 
         yaml_source = split_contents[1]
 
@@ -250,14 +364,407 @@ class Command(BaseCommand):
 
         return parsed_metadata
 
-    def assign_contract_metadata(
+    def assign_signing_party_metadata(
+        self, slug: str, contract: Contract, signing_party: dict
+    ) -> tuple[
+        Contract | Signee,
+        list[ContractIssue],
+        list[ContracteeSignatureRepresentative | SigneeSignatureRepresentative],
+        bool,
+        int,
+    ]:
+        issue_count = 0
+        issues = []
+
+        if (
+            "jméno" not in signing_party
+            and "název" not in signing_party
+            and "název společnosti" not in signing_party
+        ):
+            issue_count += 1
+            contract.notes += (
+                f"Nepojmenovaná smluvní strana, zdrojová data: {signing_party}\n"
+            )
+            issues.append(self.use_issue(contract, "Špatně pojmenovaná smluvní strana"))
+
+            if self.verbosity >= 2:
+                self.stderr.write(
+                    self.style.NOTICE(
+                        f"Contract {slug} has an unnamed signing party: {signing_party}."
+                    )
+                )
+
+            return issue_count
+
+        name = signing_party.get(
+            "jméno", signing_party.get("název", signing_party.get("název společnosti"))
+        ).strip()
+
+        patterns = (
+            (r"\s\s+", " "),
+            (r"^(1\. Pirátská s\.r\.o|1\.Pirátská s\.r\.o\.)$", "1. Pirátská s.r.o."),
+            (r"České pojišťovna, a.s.", "Česká pojišťovna, a.s."),
+            (r"Datrolex, s.r.o.", "DATROLEX, s.r.o."),
+            (r"^Jiri ", "Jiří "),
+            (
+                (
+                    r"^(Křesťanská a demokratická unie – Československá strana lidová|"
+                    r"Křesťansko demokratická unie – Československá strana lidová|Křes"
+                    r"ťanská a demokratická unie - Československá strana lidová)$"
+                ),
+                "Křesťanská a demokratická unie – Československá strana lidová",
+            ),
+            (r"LN - Audit s\.r\.o\." "LN-AUDIT s.r.o."),
+            (r"Olga Richteová", "Olga Richterová"),
+            (
+                r"^(politické hnutí Změna|PolitickéHnutí Změna)$",
+                "Politické hnutí Změna",
+            ),
+            (r"^Systemický institut s\.r\.o\$", "Systemický institut, s.r.o."),
+            (r"^Václav fořtík$", "Václav Fořtík"),
+            (r"^Vodafone$", "Vodafone Czech Republic a.s."),
+            (r"^VojtěchHolík$", "Vojtěch Holík"),
+            (r"^Vojtech ", "Vojtěch "),
+            (r"^Zdenek ", "Zdeněk "),
+            (r" Bohmova$", " Bohmová"),
+            (r" (KUdláčková|Kudlláčková)$", " Kudláčková"),
+            (r"^Jiří knotek$", "Jiří Knotek"),
+            (r"^JIří Roubíček$", "Jiří Roubíček"),
+            (r"^Koalice Vlasta\. z\.s\.$", "Koalice Vlasta, z.s."),
+            (r"^Mikuáš ", "Mikuláš "),
+            (r"^Strana zelených$", "Strana Zelených"),
+            (r"^Systemický institut s\.r\.o\.$", "Systemický institut, s.r.o."),
+            (r"^Adéla hradilová$", "Adéla Hradilová"),
+        )
+
+        for pattern in patterns:
+            name = re.sub(pattern[0], pattern[1], name)
+
+        self.normalization_count += 1
+
+        is_contractee = False
+        representatives = []
+
+        if name.lower() in (
+            "česká pirátská strana",
+            "česká pirástká strana",
+            "česká pirátkská strana",
+            "česká pirátská stran",
+        ):
+            model = Contractee
+            representative_model = ContracteeSignatureRepresentative
+            instance = model()
+            is_contractee = True
+        else:
+            model = Signee
+            representative_model = SigneeSignatureRepresentative
+            instance = model(name=name, address_country="Česká republika")
+
+        for signing_party_key, signing_party_value in signing_party.items():
+            if isinstance(signing_party_value, str):
+                signing_party_value = signing_party_value.strip()
+
+            match signing_party_key:
+                case ["sídlo" | "bydliště"]:
+                    if is_contractee:
+                        continue
+
+                    if not isinstance(signing_party_value, str):
+                        issue_count += 1
+                        contract.notes += f"Špatně zadané sídlo smluvní strany: {signing_party_value}\n"
+                        issues.append(
+                            self.use_issue(
+                                contract, "Špatně zadané sídlo smluvní strany"
+                            )
+                        )
+
+                        if self.verbosity >= 2:
+                            self.stderr.write(
+                                self.style.NOTICE(
+                                    f"Contract {slug} has an invalid signing party address: {signing_party_value}."
+                                )
+                            )
+
+                        continue
+
+                    raw_parsed_address_data = parse_address(signing_party_value)
+                    address = {}
+
+                    # Convert to a dict first, so that we can access other keys in the loop later
+                    for address_info in raw_parsed_address_data:
+                        address_value, address_key = address_info
+                        address[address_key] = address_value
+
+                    instance.address_street_with_number = ""
+
+                    if "road" in address:
+                        instance.address_street_with_number = string.capwords(
+                            address["road"]
+                        )
+
+                    if "house_number" in address:
+                        instance.address_street_with_number += (
+                            f" {address['house_number']}"
+                        )
+
+                    for address_key, address_value in address.items():
+                        match address_key:
+                            case "city":
+                                if "district" not in address:
+                                    instance.address_district = string.capwords(
+                                        address_value
+                                    )
+                            case "house":
+                                if "city" not in address and "district" not in address:
+                                    instance.address_district = string.capwords(
+                                        address_value
+                                    )
+                            case "city_district":
+                                instance.address_district = string.capwords(
+                                    address_value
+                                )
+                            case "postcode":
+                                instance.address_zip = string.capwords(address_value)
+
+                    self.normalization_count += 1
+                case "IČ":
+                    if is_contractee:
+                        continue
+
+                    if not isinstance(signing_party_value, int | str):
+                        issue_count += 1
+                        contract.notes += (
+                            f"Špatně zadané IČO smluvní strany: {signing_party_value}\n"
+                        )
+                        issues.append(
+                            self.use_issue(contract, "Špatně zadané IČO smluvní strany")
+                        )
+
+                        if self.verbosity >= 2:
+                            self.stderr.write(
+                                self.style.NOTICE(
+                                    f"Contract {slug} has an invalid signing party IČO: {signing_party_value}."
+                                )
+                            )
+
+                        continue
+
+                    instance.ico_number = str(signing_party_value)
+                case "zástupce":
+                    if not isinstance(signing_party_value, str | list):
+                        issue_count += 1
+                        contract.notes += f"Špatně zadaný zástupce smluvní strany: {signing_party_value}\n"
+                        issues.append(
+                            self.use_issue(
+                                contract, "Špatně zadaný zástupce smluvní strany"
+                            )
+                        )
+
+                        if self.verbosity >= 2:
+                            self.stderr.write(
+                                self.style.NOTICE(
+                                    f"Contract {slug} has an invalid signing party "
+                                    f"representative: {signing_party_value}."
+                                )
+                            )
+
+                        continue
+
+                    if isinstance(signing_party_value, str):
+                        signing_party_value = re.sub(r",$", "", signing_party_value)
+                        self.normalization_count += 1
+
+                        function = None
+
+                        if "funkce" in signing_party:
+                            if isinstance(signing_party["funkce"], str):
+                                function = signing_party["funkce"]
+                            else:
+                                issue_count += 1
+                                contract.notes += f"Špatně zadaná funkce zástupce smluvní strany: {signing_party['funkce']}\n"
+                                issues.append(
+                                    self.use_issue(
+                                        contract,
+                                        "Špatně zadaná funkce zástupce smluvní strany",
+                                    )
+                                )
+
+                                if self.verbosity >= 2:
+                                    self.stderr.write(
+                                        self.style.NOTICE(
+                                            f"Contract {slug} has an invalid signing party "
+                                            f"representative function: {signing_party['funkce']}."
+                                        )
+                                    )
+
+                        representatives.append(
+                            representative_model(name=signing_party_value)
+                        )
+                    else:
+                        for representative_name in signing_party_value:
+                            if not isinstance(representative_name, str):
+                                issue_count += 1
+                                contract.notes += f"Špatně zadaný jeden ze zástupců smluvní strany: {representative_name}\n"
+                                issues.append(
+                                    self.use_issue(
+                                        contract,
+                                        "Špatně zadaný zástupce smluvní strany",
+                                    )
+                                )
+
+                                if self.verbosity >= 2:
+                                    self.stderr.write(
+                                        self.style.NOTICE(
+                                            f"Contract {slug} has an invalid signing party "
+                                            f"representative list item: {representative_name}."
+                                        )
+                                    )
+
+                                continue
+
+                            representative_name = re.sub(r",$", "", representative_name)
+                            self.normalization_count += 1
+
+                            representatives.append(
+                                representative_model(name=signing_party_value)
+                            )
+                case "orgán":
+                    if not isinstance(signing_party_value, str):
+                        issue_count += 1
+                        contract.notes += f"Špatně zadaný orgán smluvní strany: {signing_party_value}\n"
+                        issues.append(
+                            self.use_issue(
+                                contract, "Špatně zadaný orgán smluvní strany"
+                            )
+                        )
+
+                        if self.verbosity >= 2:
+                            self.stderr.write(
+                                self.style.NOTICE(
+                                    f"Contract {slug} has an invalid signing party "
+                                    f"department: {signing_party_value}."
+                                )
+                            )
+
+                        continue
+
+                    if signing_party_value in (
+                        "Česká Pirátská strana",
+                        "Česká pirátská strana",
+                    ):
+                        # Irrelevant
+                        continue
+
+                    instance.department = self.normalize_department(signing_party_value)
+                    self.normalization_count += 1
+
+        if model is Signee:
+            if (
+                "s.r.o" in instance.name
+                or "s. r. o." in instance.name
+                or "a.s." in instance.name
+                or "a. s." in instance.name
+                or "o.s." in instance.name
+                or "o. s." in instance.name
+                or "z.s." in instance.name
+                or "z. s." in instance.name
+                or "1" in instance.name
+                or "2" in instance.name
+                or "3" in instance.name
+                or "4" in instance.name
+                or "5" in instance.name
+                or "6" in instance.name
+                or "7" in instance.name
+                or "8" in instance.name
+                or "9" in instance.name
+                or "0" in instance.name
+                or len(instance.name.split(" ")) not in (2, 3)
+            ):
+                instance.entity_type = instance.EntityTypes.LEGAL_ENTITY
+            else:
+                if instance.ico_number is None:
+                    instance.entity_type = instance.EntityTypes.NATURAL_PERSON
+                else:
+                    instance.entity_type = instance.EntityTypes.BUSINESS_NATURAL_PERSON
+
+        # Do our best to merge signing parties together.
+        existing_instances = model.objects.filter(
+            (
+                models.Q(name=instance.name)
+                & (
+                    models.Q(department=instance.department)
+                    if instance.department is not None
+                    else models.Q(department__isnull=True)
+                )
+                & (
+                    (
+                        models.Q(
+                            address_street_with_number=instance.address_street_with_number
+                        )
+                        if instance.address_street_with_number is not None
+                        else models.Q(address_street_with_number__isnull=True)
+                    )
+                    | (
+                        models.Q(date_of_birth=instance.date_of_birth)
+                        if model is Signee and instance.date_of_birth is not None
+                        else (
+                            models.Q(date_of_birth__isnull=True)
+                            if model is Signee
+                            else models.Value(False)
+                        )
+                    )
+                )
+            )
+            | (
+                (
+                    models.Q(ico_number=instance.ico_number)
+                    & (
+                        models.Q(department=instance.department)
+                        if instance.department is not None
+                        else models.Q(department__isnull=True)
+                    )
+                )
+                if instance.ico_number is not None
+                else models.Value(False)
+            )
+        ).all()
+
+        if len(existing_instances) != 0:
+            for position, existing_instance in enumerate(existing_instances):
+                if (
+                    existing_instance.ico_number is None
+                    and instance.ico_number is not None
+                ):
+                    existing_instance.ico_number = instance.ico_number
+                    existing_instance.save()
+                    instance = existing_instance
+                    break
+                elif (
+                    existing_instance.ico_number == instance.ico_number
+                    or instance.ico_number is None
+                ):
+                    instance = existing_instance
+                    break
+                elif position == len(existing_instances) - 1:
+                    instance.save()
+        else:
+            instance.save()
+
+        return instance, issues, representatives, is_contractee, issue_count
+
+    def assign_contract_data(
         self,
         contract: Contract,
         metadata: dict,
         slug: str,
+        contract_root: str,
     ) -> None:
         filing_area = None
         types = []
+        signees = []
+        contractees = []
+        files = []
+        issues = []
         is_already_imported = False
         observed_issues_count = 0
 
@@ -275,6 +782,9 @@ class Command(BaseCommand):
                     elif value is not None:
                         observed_issues_count += 1
                         contract.notes += f"Špatně zadaný začátek platnosti: {value}\n"
+                        issues.append(
+                            self.use_issue(contract, "Špatně zadaný začátek platnosti")
+                        )
 
                         if self.verbosity >= 2:
                             self.stderr.write(
@@ -291,6 +801,9 @@ class Command(BaseCommand):
                     ):
                         observed_issues_count += 1
                         contract.notes += f"Špatně zadaný konec platnosti: {value}\n"
+                        issues.append(
+                            self.use_issue(contract, "Špatně zadaný konec platnosti")
+                        )
 
                         if self.verbosity >= 2:
                             self.stderr.write(
@@ -313,6 +826,7 @@ class Command(BaseCommand):
                 case "použité smluvní typy":
                     if isinstance(value, str):
                         value = self.normalize_type(value)
+                        self.normalization_count += 1
 
                         try:
                             type_instance = ContractType.objects.get(name=value)
@@ -325,6 +839,7 @@ class Command(BaseCommand):
                     elif not isinstance(value, list):
                         observed_issues_count += 1
                         contract.notes += f"Špatně zadané typy: {value}\n"
+                        issues.append(self.use_issue(contract, "Špatně zadané typy"))
 
                         if self.verbosity >= 2:
                             self.stderr.write(
@@ -338,7 +853,8 @@ class Command(BaseCommand):
                     for type_name in value:
                         if not isinstance(type_name, str):
                             observed_issues_count += 1
-                            contract.notes += f"Nezaevidovaný typ: {type_name}\n"
+                            contract.notes += f"Špatně zadaný typ: {type_name}\n"
+                            issues.append(self.use_issue(contract, "Špatně zadaný typ"))
 
                             if self.verbosity >= 2:
                                 self.stderr.write(
@@ -350,6 +866,7 @@ class Command(BaseCommand):
                             continue
 
                         type_name = self.normalize_type(type_name)
+                        self.normalization_count += 1
 
                         try:
                             type_instance = ContractType.objects.get(name=type_name)
@@ -379,6 +896,7 @@ class Command(BaseCommand):
                     else:
                         observed_issues_count += 1
                         contract.notes += f"Neznámý stav: {value}\n"
+                        issues.append(self.use_issue(contract, "Neznámý právní stav"))
 
                         if self.verbosity >= 2:
                             self.stderr.write(
@@ -399,6 +917,9 @@ class Command(BaseCommand):
                             contract.notes += (
                                 f"Původní, špatně zadané náklady: {value}\n"
                             )
+                            issues.append(
+                                self.use_issue(contract, "Špatně zadané náklady")
+                            )
 
                             if self.verbosity >= 2:
                                 self.stderr.write(
@@ -426,6 +947,9 @@ class Command(BaseCommand):
                         ):
                             observed_issues_count += 1
                             contract.notes += f"Původní, neropoznané náklady: {value}\n"
+                            issues.append(
+                                self.use_issue(contract, "Špatně zadané náklady")
+                            )
 
                             if self.verbosity >= 2:
                                 self.stderr.write(
@@ -441,6 +965,7 @@ class Command(BaseCommand):
                     elif value not in (None, "0"):
                         observed_issues_count += 1
                         contract.notes += f"Původní, neropoznané náklady: {value}\n"
+                        issues.append(self.use_issue(contract, "Špatně zadané náklady"))
 
                         if self.verbosity >= 2:
                             self.stderr.write(
@@ -451,6 +976,7 @@ class Command(BaseCommand):
                 case "místo uložení":
                     if isinstance(value, str):
                         value = self.normalize_filing_area(value)
+                        self.normalization_count += 1
 
                     try:
                         contract.paper_form_state = contract.PaperFormStates.STORED
@@ -464,6 +990,9 @@ class Command(BaseCommand):
                         else:
                             observed_issues_count += 1
                             contract.notes += f"Špatně zadaná spisovna: {value}\n"
+                            issues.append(
+                                self.use_issue(contract, "Špatně zadaná spisovna")
+                            )
 
                             if self.verbosity >= 2:
                                 self.stderr.write(
@@ -471,14 +1000,164 @@ class Command(BaseCommand):
                                         f"Contract {slug} has an invalid filing area: {value}."
                                     )
                                 )
+                case "smluvní strany":
+                    if not isinstance(value, list):
+                        observed_issues_count += 1
+                        contract.notes += (
+                            f"Špatně zadané smluvní strany, nejsou seznam: {value}\n"
+                        )
+                        issues.append(
+                            self.use_issue(contract, "Špatně zadaný smluvní strany")
+                        )
+
+                        if self.verbosity >= 2:
+                            self.stderr.write(
+                                self.style.NOTICE(
+                                    f"Signing parties on {slug} are not a list: {value}."
+                                )
+                            )
+
+                        continue
+
+                    for signing_party in value:
+                        if not isinstance(signing_party, dict):
+                            observed_issues_count += 1
+                            contract.notes += (
+                                f"Špatně zadaná smluvní strana: {signing_party}\n"
+                            )
+                            issues.append(
+                                self.use_issue(contract, "Špatně zadaná smluvní strana")
+                            )
+
+                            if self.verbosity >= 2:
+                                self.stderr.write(
+                                    self.style.NOTICE(
+                                        f"Signing party on {slug} is not a dictionary: {value}."
+                                    )
+                                )
+
+                            continue
+
+                        (
+                            instance,
+                            signing_party_issues,
+                            representatives,
+                            is_contractee,
+                            signing_party_issue_count,
+                        ) = self.assign_signing_party_metadata(
+                            slug, contract, signing_party
+                        )
+
+                        issues += signing_party_issues
+                        observed_issues_count += signing_party_issue_count
+
+                        # Store representatives in relation to the instance, hacky but good enough
+                        instance._representatives = representatives
+
+                        if is_contractee:
+                            contractees.append(instance)
+                        else:
+                            signees.append(instance)
+                case "soubory":
+                    if not isinstance(value, list):
+                        observed_issues_count += 1
+                        contract.notes += f"Špatně zadané soubory.\n"
+                        issues.append(self.use_issue(contract, "Špatně zadané soubory"))
+
+                        if self.verbosity >= 2:
+                            self.stderr.write(
+                                self.style.NOTICE(
+                                    f"Files for {slug} are not a list: {value}."
+                                )
+                            )
+
+                        continue
+
+                    for file_data in value:
+                        if not isinstance(file_data, dict):
+                            observed_issues_count += 1
+                            contract.notes += (
+                                f"Špatně zadané informace o souboru: {file_data}.\n"
+                            )
+                            issues.append(
+                                self.use_issue(
+                                    contract, "Špatně zadané informace o souboru"
+                                )
+                            )
+
+                            if self.verbosity >= 2:
+                                self.stderr.write(
+                                    self.style.NOTICE(
+                                        f"File data in {slug} is not a dict: {file_data}."
+                                    )
+                                )
+
+                            continue
+
+                        for file_key, file_value in file_data.items():
+                            file_key = file_key.strip()
+
+                            if file_key.lower() in ("název", "náhled", "náhlad"):
+                                continue
+
+                            if not isinstance(file_value, str):
+                                observed_issues_count += 1
+                                contract.notes += f"Špatně zadaný název souboru {file_key}: {file_value}.\n"
+                                issues.append(
+                                    self.use_issue(contract, "Neplatný název souboru")
+                                )
+
+                                if self.verbosity >= 2:
+                                    self.stderr.write(
+                                        self.style.NOTICE(
+                                            f"Filename in {slug} for file {file_key} invalid: {file_value}."
+                                        )
+                                    )
+
+                                continue
+
+                            file_path = os.path.join(contract_root, file_value)
+
+                            if not os.path.isfile(file_path):
+                                observed_issues_count += 1
+                                contract.notes += (
+                                    f"Neexistující soubor: {file_value}.\n"
+                                )
+                                issues.append(
+                                    self.use_issue(contract, "Neexistující soubor")
+                                )
+
+                                if self.verbosity >= 2:
+                                    self.stderr.write(
+                                        self.style.NOTICE(
+                                            f"Filename in {slug} does not correspond to a file: {file_value}."
+                                        )
+                                    )
 
                                 continue
 
+                            with open(file_path, "rb") as open_file:
+                                self.normalization_count += 1
+                                file = ContractFile(
+                                    contract=contract,
+                                    name=self.normalize_filename(file_key),
+                                    is_public=True,
+                                )
+
+                                file.file.save(
+                                    file_value,
+                                    File(open_file),
+                                    save=False,
+                                )
+
+                                files.append(file)
+
         if not is_already_imported:
             if contract.name in (None, "") or (
                 isinstance(contract.name, str)
                 and re.sub(r"/\s\s+/", "", contract.name) == ""
             ):
+                self.normalization_count += 1
                 contract.name = slug
 
             if contract.valid_start_date is None:
@@ -499,8 +1178,49 @@ class Command(BaseCommand):
             # Save primary key first
             contract.save()
 
+            for contractee in contractees:
+                contractee.save()
+
+                signature = ContracteeSignature(
+                    contract=contract,
+                    contractee=contractee,
+                    date=contract.valid_start_date,
+                )
+
+                signature.save()
+
+                contract.contractee_signatures.add(signature)
+
+                for representative in contractee._representatives:
+                    representative.signature = signature
+                    representative.save()
+
+            for signee in signees:
+                signee.save()
+
+                signature = SigneeSignature(
+                    contract=contract,
+                    signee=signee,
+                    date=contract.valid_start_date,
+                )
+
+                signature.save()
+
+                contract.signee_signatures.add(signature)
+
+                for representative in signee._representatives:
+                    representative.signature = signature
+                    representative.save()
+
+            for file in files:
+                file.save()
+
+            for issue in issues:
+                issue.save()
+
             contract.filing_area = filing_area
             contract.types.set(types)
+            contract.issues.set(issues)
             contract.save()
         else:
             self.already_imported_count += 1
@@ -535,10 +1255,11 @@ class Command(BaseCommand):
 
                         return
 
-                    self.assign_contract_metadata(
+                    self.assign_contract_data(
                         contract,
                         metadata,
                         os.path.basename(contract_root),
+                        contract_root,
                     )
                 elif file_.endswith(".pdf"):
                     # TODO
@@ -611,7 +1332,8 @@ class Command(BaseCommand):
                     f"Saved a total of {self.normal_import_count + self.partial_import_count} contracts.\n"
                     f"    {self.partial_import_count} contained a total of {self.issue_count} issues.\n"
                     f"    {self.already_imported_count} were already saved previously and skipped.\n"
-                    f"    {self.fatal_error_count} potential contracts were unparseable."
+                    f"    {self.fatal_error_count} potential contracts were unparseable.\n"
+                    f"    {self.normalization_count} data points were normalized."
                 )
             )
 
@@ -623,7 +1345,7 @@ class Command(BaseCommand):
             (options["directory"] if options["directory"] is not None else "git"),
         )
 
-        if os.path.exists(git_dir):
+        if os.path.exists(git_dir) and not options["delete"]:
             if not options["existing"]:
                 if self.verbosity >= 1:
                     self.stderr.write(
@@ -640,6 +1362,12 @@ class Command(BaseCommand):
                 if self.verbosity >= 2:
                     self.stdout.write("Using existing git storage directory.")
         else:
+            if options["delete"] and os.path.exists(git_dir):
+                if self.verbosity >= 2:
+                    self.stdout.write("Deleting old git storage directory.")
+
+                shutil.rmtree(git_dir)
+
             if self.verbosity >= 2:
                 self.stdout.write("Cloning repository.")
 
@@ -653,9 +1381,17 @@ class Command(BaseCommand):
                 self.stdout.write(self.style.SUCCESS("Finished cloning repository."))
 
         if options["purge"]:
-            Contract.objects.filter().delete()
-            ContractType.objects.filter().delete()
-            ContractFilingArea.objects.filter().delete()
+            for model in (
+                Contract,
+                ContractType,
+                ContractFilingArea,
+                ContractFile,
+                Contractee,
+                ContracteeSignature,
+                Signee,
+                SigneeSignature,
+            ):
+                model.objects.filter().delete()
 
             if self.verbosity >= 1:
                 self.stdout.write(self.style.SUCCESS("Deleted all previous records."))