StrictDoc Documentation
strictdoc/export/html/form_objects/document_config_form_object.py
Source file coverage
Path:
strictdoc/export/html/form_objects/document_config_form_object.py
Lines:
195
Non-empty lines:
170
Non-empty lines covered with requirements:
170 / 170 (100.0%)
Functions:
9
Functions covered by requirements:
9 / 9 (100.0%)
1
"""
2
@relation(SDOC-SRS-57, scope=file)
3
"""
4
 
5
from typing import Dict, List, Optional
6
 
7
from starlette.datastructures import FormData
8
 
9
from strictdoc.backend.sdoc.models.document import SDocDocument
10
from strictdoc.helpers.auto_described import auto_described
11
from strictdoc.helpers.cast import assert_cast
12
from strictdoc.helpers.form_data import ParsedFormData, parse_form_data
13
from strictdoc.helpers.mid import MID
14
from strictdoc.helpers.string import sanitize_html_form_field
15
from strictdoc.server.error_object import ErrorObject
16
 
17
 
18
@auto_described
19
class DocumentMetadataFormField:
20
    def __init__(
21
        self,
22
        field_mid: str,
23
        field_name: str,
24
        field_value: str,
25
    ):
26
        assert isinstance(field_value, str)
27
        self.field_mid: str = field_mid
28
        self.field_name: str = field_name
29
        self.field_value: str = field_value
30
 
31
    @staticmethod
32
    def create_from_document(
33
        name: str, value: str
34
    ) -> "DocumentMetadataFormField":
35
        return DocumentMetadataFormField(
36
            field_mid=MID.create(), field_name=name, field_value=value
37
        )
38
 
39
    def get_input_field_name(self) -> str:
40
        return f"metadata[{self.field_mid}][name]"
41
 
42
    def get_input_field_value(self) -> str:
43
        return f"metadata[{self.field_mid}][value]"
44
 
45
 
46
@auto_described
47
class DocumentConfigFormObject(ErrorObject):
48
    def __init__(
49
        self,
50
        *,
51
        document_mid: str,
52
        document_title: str,
53
        document_uid: Optional[str],
54
        document_version: Optional[str],
55
        document_classification: Optional[str],
56
        document_requirement_prefix: Optional[str],
57
        document_custom_metadata_fields: List[DocumentMetadataFormField],
58
    ):
59
        assert isinstance(document_mid, str), document_mid
60
        assert isinstance(document_title, str), document_title
61
        super().__init__()
62
        self.document_mid: Optional[str] = document_mid
63
        self.document_title: str = document_title
64
        self.document_uid: Optional[str] = (
65
            document_uid if document_uid is not None else ""
66
        )
67
        self.document_version: Optional[str] = (
68
            document_version if document_version is not None else ""
69
        )
70
        self.document_classification: Optional[str] = (
71
            document_classification
72
            if document_classification is not None
73
            else ""
74
        )
75
        self.document_requirement_prefix: Optional[str] = (
76
            document_requirement_prefix
77
            if document_requirement_prefix is not None
78
            else ""
79
        )
80
        self.custom_metadata_fields: List[DocumentMetadataFormField] = (
81
            document_custom_metadata_fields
82
        )
83
 
84
    @staticmethod
85
    def create_from_request(
86
        *, document_mid: str, request_form_data: FormData
87
    ) -> "DocumentConfigFormObject":
88
        request_form_data_as_list = [
89
            (field_name, field_value)
90
            for field_name, field_value in request_form_data.multi_items()
91
        ]
92
        request_form_dict: ParsedFormData = assert_cast(
93
            parse_form_data(request_form_data_as_list), dict
94
        )
95
 
96
        config_fields: Dict[str, str] = assert_cast(
97
            request_form_dict["document"], dict
98
        )
99
 
100
        metadata_fields: Dict[str, Dict[str, str]] = (
101
            assert_cast(request_form_dict["metadata"], dict)
102
            if "metadata" in request_form_dict
103
            else {}
104
        )
105
 
106
        document_title: str = (
107
            config_fields["TITLE"] if "TITLE" in config_fields else ""
108
        )
109
        document_title = sanitize_html_form_field(
110
            document_title, multiline=False
111
        )
112
        document_title = document_title if document_title is not None else ""
113
 
114
        document_uid: str = ""
115
        if "UID" in config_fields:
116
            document_uid = config_fields["UID"]
117
            document_uid = sanitize_html_form_field(
118
                document_uid, multiline=False
119
            )
120
 
121
        document_version: str = ""
122
        if "VERSION" in config_fields:
123
            document_version = config_fields["VERSION"]
124
            document_version = sanitize_html_form_field(
125
                document_version, multiline=False
126
            )
127
 
128
        document_classification: str = ""
129
        if "CLASSIFICATION" in config_fields:
130
            document_classification = config_fields["CLASSIFICATION"]
131
            document_classification = sanitize_html_form_field(
132
                document_classification, multiline=False
133
            )
134
 
135
        document_requirement_prefix: str = ""
136
        if "PREFIX" in config_fields:
137
            document_requirement_prefix = config_fields["PREFIX"]
138
            document_requirement_prefix = sanitize_html_form_field(
139
                document_requirement_prefix, multiline=False
140
            )
141
 
142
        document_custom_metadata_fields: List[DocumentMetadataFormField] = []
143
        for field_mid, field_dict in metadata_fields.items():
144
            assert isinstance(field_dict, dict), type(field_dict)
145
 
146
            field_name = field_dict["name"].strip()
147
            field_value = field_dict["value"].strip()
148
 
149
            document_custom_metadata_field = DocumentMetadataFormField(
150
                field_mid=field_mid,
151
                field_name=field_name,
152
                field_value=field_value,
153
            )
154
            document_custom_metadata_fields.append(
155
                document_custom_metadata_field
156
            )
157
 
158
        form_object = DocumentConfigFormObject(
159
            document_mid=document_mid,
160
            document_title=document_title,
161
            document_uid=document_uid,
162
            document_version=document_version,
163
            document_classification=document_classification,
164
            document_requirement_prefix=document_requirement_prefix,
165
            document_custom_metadata_fields=document_custom_metadata_fields,
166
        )
167
        return form_object
168
 
169
    @staticmethod
170
    def create_from_document(
171
        *,
172
        document: SDocDocument,
173
    ) -> "DocumentConfigFormObject":
174
        assert isinstance(document, SDocDocument)
175
 
176
        document_custom_metadata_fields: List[DocumentMetadataFormField] = []
177
        for name, value in document.config.get_custom_metadata():
178
            document_custom_metadata_field = (
179
                DocumentMetadataFormField.create_from_document(
180
                    name=name, value=value
181
                )
182
            )
183
            document_custom_metadata_fields.append(
184
                document_custom_metadata_field
185
            )
186
 
187
        return DocumentConfigFormObject(
188
            document_mid=document.reserved_mid,
189
            document_title=document.title,
190
            document_uid=document.config.uid,
191
            document_version=document.config.version,
192
            document_classification=document.config.classification,
193
            document_requirement_prefix=document.config.requirement_prefix,
194
            document_custom_metadata_fields=document_custom_metadata_fields,
195
        )
1 - 195 | entire file