Skip to content

catalogs API

client.catalogs reads the post-definition catalogs and their entries, and writes catalogs and entries through the admin endpoints (admin permissions required).

Reading

from pynteracta.client import InteractaClient

with InteractaClient(base_url="https://tenant.example.com", credentials=...) as client:
    catalogs = client.catalogs.list([5, 8], load_entries=True)
    for catalog in catalogs.items_typed:
        print(catalog.id, catalog.name, catalog.paged)

    for entry in client.catalogs.iterate_entries(5, page_size=50):
        print(entry.id, entry.label, entry.external_id)

Pass the catalog IDs: list() without IDs answers an empty CatalogList, whether the client logs in with a service account or with Google OAuth2 (verified on the test tenant), even when the same catalogs are readable by ID. The IDs used by a community's fields are in the field metadata of its post definition, as strings:

with InteractaClient(base_url="https://tenant.example.com", credentials=...) as client:
    definition = client.communities.post_definition(21)
    catalog_ids = sorted(
        {
            int(field.metadata["catalog_id"])
            for field in definition.field_definitions
            if field.metadata and "catalog_id" in field.metadata
        }
    )
    catalogs = client.catalogs.list(catalog_ids)

A disabled catalog is no longer returned: list([id]) with a disabled catalog answers 400 with NOT_EXISTS on catalogIds.

Edit forms

get_for_edit(catalog_id) and get_entry_for_edit(catalog_id, entry_id) read the admin edit forms. They are aliases of client.admin_manage.catalog_for_edit() and catalog_entry_for_edit(): same request, same facade. Each facade exposes occ_token, the concurrency token for the next edit; CatalogForEdit also exposes parent_catalog_id. Languages whose value is null in a name or label map are dropped from the facade.

Writing catalogs

with InteractaClient(base_url="https://tenant.example.com", credentials=...) as client:
    created = client.catalogs.create(name={"it": "Sedi", "en": "Sites"}, parent_id=3)
    print(created.catalog_id, created.next_occ_token)

    form = client.catalogs.get_for_edit(created.catalog_id)
    # The name map is replaced as a whole: pass every language you want to keep.
    edited = client.catalogs.edit(
        created.catalog_id, form.occ_token, name={**form.name, "en": "Offices"}
    )

    client.catalogs.set_deleted(created.catalog_id, True)   # logical deletion
    client.catalogs.set_deleted(created.catalog_id, False)  # restore
  • create(name=..., parent_id=...) and edit(catalog_id, occ_token, name=..., parent_id=...) send only the fields given and return a CatalogWriteResult (catalog_id, catalog, parent_catalog, next_occ_token, .raw).
  • set_deleted(catalog_id, deleted) changes the logical deleted flag (no occToken needed) and returns a CatalogDeletedResult (catalog_id, entry_id, deleted, .raw). Catalogs are never removed: the API has no physical deletion.
  • deleted is not an argument of edit: use set_deleted, or edit_raw with a CreateEditCatalogRequestDTO if you need it in the PUT.
  • create_raw(req) and edit_raw(catalog_id, req) take a pre-built DTO.

Omitted fields (verified on the test tenant): the server replaces the whole name map on every edit. The languages missing from name lose their text, and the it language takes the text you passed. Read the form and send the full map, as above; catalogs edit in the CLI does it for you.

Writing catalog entries

with InteractaClient(base_url="https://tenant.example.com", credentials=...) as client:
    entry = client.catalogs.create_entry(5, label={"it": "Bologna"}, external_id="BO")
    form = client.catalogs.get_entry_for_edit(5, entry.entry_id)
    client.catalogs.edit_entry(
        5,
        entry.entry_id,
        form.occ_token,
        label={**form.label, "en": "Bologna"},
        external_id=form.external_id,
    )
    client.catalogs.set_entry_deleted(5, entry.entry_id, True)
  • create_entry(catalog_id, label=..., parent_ids=..., external_id=...) and edit_entry(catalog_id, entry_id, occ_token, ...) return a CatalogEntryWriteResult (entry_id, catalog_id, entry, next_occ_token, .raw).
  • set_entry_deleted(catalog_id, entry_id, deleted) returns a CatalogDeletedResult. The swagger declares the catalog response (catalogId), but the tenant answers with entryId: the result always has both ids, completing the missing one with the id you passed.

Omitted fields (verified on the test tenant): the label map is replaced as a whole, like the catalog name, and the external id and the parent entries missing from the request are cleared. Send them back from the form, as above; catalogs edit-entry in the CLI does it for you.

Every write sends one request and never retries: a 409 raises ConcurrencyError, a timeout or network error raises TransportError with an unknown outcome (ADR 0001).

API Reference

pynteracta.api.catalogs.CatalogsAPI

Bases: ResourceClient

Client for post-definition catalog endpoints and the admin catalog writes.

Le scritture (spec 06) inviano solo i campi passati, in una sola richiesta: un errore del server o di rete risale al chiamante, mai un nuovo tentativo (ADR 0001). Il token di concorrenza lo fornisce il chiamante, letto da :meth:get_for_edit o :meth:get_entry_for_edit; un 409 è ConcurrencyError. Il flag deleted si cambia con :meth:set_deleted e :meth:set_entry_deleted (cancellazione logica, reversibile), non con edit; chi lo vuole nel PUT usa le varianti *_raw. La semantica del server sui campi omessi è documentata in docs/api/catalogs.md.

list(catalog_ids=None, *, load_entries=False)

POST /communication/settings/post-definition/catalogs.

Legge le intestazioni dei cataloghi con gli id indicati. Non è un filtro: senza id il server risponde con una lista vuota (verificato sul tenant con service account e Google OAuth2). Gli id si ricavano da metadata["catalog_id"] dei campi della definizione dei post di una community.

Parameters:

Name Type Description Default
catalog_ids list[int] | None

Id dei cataloghi da leggere; senza id la risposta è vuota.

 None
load_entries bool

Con True include le voci di ogni catalogo nella risposta.

 False

list_raw(req, *, load_entries=False)

POST catalog list with a pre-built request DTO (escape hatch).

entries(catalog_id, *, page_token=None, page_size=None, calculate_total_items_count=None, label=None, order_by=None, order_desc=None, **filters)

POST /communication/settings/post-definition/catalogs/{catalogId}/entries.

Retrieve a page of entries for the given catalog.

Parameters:

Name Type Description Default
catalog_id int

Unique catalog identifier.

 required
page_token str | None

Pagination token from a previous response.

 None
page_size int | None

Number of entries per page.

 None
calculate_total_items_count bool | None

Include total count in the response when True.

 None
label str | None

Filter entries by label substring.

 None
order_by str | None

Sort field (label or externalId).

 None
order_desc bool | None

Sort descending when True.

 None

entries_raw(catalog_id, req)

POST catalog entries with a pre-built request DTO (escape hatch).

iterate_entries(catalog_id, *, page_size=None, **filters)

Lazy iterator over all pages of :meth:entries.

Parameters:

Name Type Description Default
catalog_id int

Unique catalog identifier.

 required
page_size int | None

Number of entries per page.

 None

get_for_edit(catalog_id)

GET /admin/manage/catalogs/{catalogId}/edit.

Alias di :meth:~pynteracta.api.admin_manage.AdminManageAPI.catalog_for_edit: stessa richiesta, stessa façade, con occ_token per :meth:edit.

get_entry_for_edit(catalog_id, entry_id)

GET /admin/manage/catalogs/{catalogId}/entries/{entryId}/edit.

Alias di :meth:~pynteracta.api.admin_manage.AdminManageAPI.catalog_entry_for_edit, con occ_token per :meth:edit_entry.

create(*, name=None, parent_id=None)

POST /admin/manage/catalogs: crea un catalogo.

Parameters:

Name Type Description Default
name dict[str, str] | None

Nome per lingua, per esempio {"it": "Sedi", "en": "Sites"}.

 None
parent_id int | None

Id del catalogo parent (dipendenza gerarchica).

 None

create_raw(req)

POST /admin/manage/catalogs da un DTO già costruito.

edit(catalog_id, occ_token, *, name=None, parent_id=None)

PUT /admin/manage/catalogs/{catalogId}: modifica un catalogo.

Il corpo contiene solo i campi passati più l'occToken; i campi omessi non vengono inviati e cosa ne fa il server è scritto in docs/api/catalogs.md.

Parameters:

Name Type Description Default
catalog_id int

Il catalogo da modificare.

 required
occ_token int

Token letto da CatalogForEdit.occ_token.

 required
name dict[str, str] | None

Nome per lingua.

 None
parent_id int | None

Id del catalogo parent.

 None

edit_raw(catalog_id, req)

PUT /admin/manage/catalogs/{catalogId} da un DTO già costruito.

Il DTO porta l'occToken e può portare deleted.

set_deleted(catalog_id, deleted)

PUT /admin/manage/catalogs/{catalogId}/deleted: disabilita o ripristina.

La cancellazione è logica: il catalogo resta sul tenant con deleted: true e si ripristina con deleted=False. L'endpoint non chiede occToken.

create_entry(catalog_id, *, label=None, parent_ids=None, external_id=None)

POST /admin/manage/catalogs/{catalogId}/entries: crea una voce.

Parameters:

Name Type Description Default
catalog_id int

Il catalogo della voce.

 required
label dict[str, str] | None

Etichetta per lingua, per esempio {"it": "Bologna"}.

 None
parent_ids list[int] | None

Id delle voci parent (cataloghi gerarchici).

 None
external_id str | None

Id esterno univoco.

 None

create_entry_raw(catalog_id, req)

POST /admin/manage/catalogs/{catalogId}/entries da un DTO già costruito.

edit_entry(catalog_id, entry_id, occ_token, *, label=None, parent_ids=None, external_id=None)

PUT /admin/manage/catalogs/{catalogId}/entries/{entryId}: modifica una voce.

Il corpo contiene solo i campi passati più l'occToken; i campi omessi non vengono inviati (semantica del server in docs/api/catalogs.md).

Parameters:

Name Type Description Default
catalog_id int

Il catalogo della voce.

 required
entry_id int

La voce da modificare.

 required
occ_token int

Token letto da CatalogEntryForEdit.occ_token.

 required
label dict[str, str] | None

Etichetta per lingua.

 None
parent_ids list[int] | None

Id delle voci parent.

 None
external_id str | None

Id esterno univoco.

 None

edit_entry_raw(catalog_id, entry_id, req)

PUT /admin/manage/catalogs/{catalogId}/entries/{entryId} da un DTO già costruito.

set_entry_deleted(catalog_id, entry_id, deleted)

PUT /admin/manage/catalogs/{catalogId}/entries/{entryId}/deleted.

Disabilita (deleted=True) o ripristina una voce; cancellazione logica, senza occToken. La risposta può portare catalogId o entryId: il risultato ha sempre entrambi gli id.

Facade models

pynteracta.models.facade.catalogs.CatalogList

Facade over :class:~generated.GetPostDefinitionCatalogsResponseDTO.

Attributes:

Name Type Description
raw

The underlying generated DTO.
Source code in src/pynteracta/models/facade/catalogs.py 
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
class CatalogList:
    """Facade over :class:`~generated.GetPostDefinitionCatalogsResponseDTO`.

    Attributes:
        raw: The underlying generated DTO.
    """

    def __init__(self, raw: generated.GetPostDefinitionCatalogsResponseDTO) -> None:
        self.raw = raw

    @property
    def items(self) -> list[generated.CatalogDTO]:
        """Raw catalog items (generated stubs)."""
        return self.raw.catalogs or []

    @property
    def items_typed(self) -> list[Catalog]:
        """Catalog items re-validated as typed :class:`Catalog` facades."""
        result = []
        for stub in self.items:
            typed = generated.CatalogDTOModel.model_validate(stub.root)
            result.append(Catalog(typed))
        return result

    @classmethod
    def from_dict(cls, data: dict) -> CatalogList:  # type: ignore[type-arg]
        """Parse from a raw API response dict."""
        return cls(generated.GetPostDefinitionCatalogsResponseDTO.model_validate(data))

items property

Raw catalog items (generated stubs).

items_typed property

Catalog items re-validated as typed :class:Catalog facades.

from_dict(data) classmethod

Parse from a raw API response dict.

Source code in src/pynteracta/models/facade/catalogs.py 
 99
100
101
102
@classmethod
def from_dict(cls, data: dict) -> CatalogList:  # type: ignore[type-arg]
    """Parse from a raw API response dict."""
    return cls(generated.GetPostDefinitionCatalogsResponseDTO.model_validate(data))

pynteracta.models.facade.catalogs.Catalog

Narrow facade over :class:~generated.CatalogDTOModel.

Attributes:

Name Type Description
raw

The underlying generated DTO; access additional fields via this escape hatch.
Source code in src/pynteracta/models/facade/catalogs.py 
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
class Catalog:
    """Narrow facade over :class:`~generated.CatalogDTOModel`.

    Attributes:
        raw: The underlying generated DTO; access additional fields via this escape hatch.
    """

    def __init__(self, raw: generated.CatalogDTOModel) -> None:
        self.raw = raw

    @property
    def id(self) -> int | None:
        """Unique catalog identifier."""
        return self.raw.id

    @property
    def name(self) -> str | None:
        """Catalog name."""
        return self.raw.name

    @property
    def paged(self) -> bool | None:
        """Whether this catalog is paginated."""
        return self.raw.paged

    @property
    def etag(self) -> int | None:
        """Versione del catalogo restituita dal server."""
        return self.raw.etag

    @property
    def entries_typed(self) -> list[CatalogEntry]:
        """Voci del catalogo, se la risposta le contiene, come façade :class:`CatalogEntry`."""
        return [CatalogEntry.from_stub(stub) for stub in self.raw.entries or []]

    @classmethod
    def from_raw(cls, raw: generated.CatalogDTOModel) -> Catalog:
        """Wrap a generated DTO."""
        return cls(raw)

    @classmethod
    def from_stub(cls, stub: generated.CatalogDTO) -> Catalog:
        """Rivalida uno stub ``CatalogDTO`` in :class:`Catalog`."""
        root = _resolve_root(stub)
        if isinstance(root, dict):
            return cls(generated.CatalogDTOModel.model_validate(root))
        msg = f"Unexpected stub root type: {type(root)}"
        raise ValueError(msg)

entries_typed property

Voci del catalogo, se la risposta le contiene, come façade :class:CatalogEntry.

etag property

Versione del catalogo restituita dal server.

id property

Unique catalog identifier.

name property

Catalog name.

paged property

Whether this catalog is paginated.

from_raw(raw) classmethod

Wrap a generated DTO.

Source code in src/pynteracta/models/facade/catalogs.py 
60
61
62
63
@classmethod
def from_raw(cls, raw: generated.CatalogDTOModel) -> Catalog:
    """Wrap a generated DTO."""
    return cls(raw)

from_stub(stub) classmethod

Rivalida uno stub CatalogDTO in :class:Catalog.

Source code in src/pynteracta/models/facade/catalogs.py 
65
66
67
68
69
70
71
72
@classmethod
def from_stub(cls, stub: generated.CatalogDTO) -> Catalog:
    """Rivalida uno stub ``CatalogDTO`` in :class:`Catalog`."""
    root = _resolve_root(stub)
    if isinstance(root, dict):
        return cls(generated.CatalogDTOModel.model_validate(root))
    msg = f"Unexpected stub root type: {type(root)}"
    raise ValueError(msg)

pynteracta.models.facade.catalogs.CatalogEntryList

Facade over :class:~generated.ListPostDefinitionCatalogEntriesResponseDTO.

Attributes:

Name Type Description
raw

The underlying generated DTO.
Source code in src/pynteracta/models/facade/catalogs.py 
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
class CatalogEntryList:
    """Facade over :class:`~generated.ListPostDefinitionCatalogEntriesResponseDTO`.

    Attributes:
        raw: The underlying generated DTO.
    """

    def __init__(self, raw: generated.ListPostDefinitionCatalogEntriesResponseDTO) -> None:
        self.raw = raw

    @property
    def items(self) -> list[generated.CatalogEntryDTO]:
        """Raw entry items (generated stubs)."""
        return self.raw.items or []

    @property
    def items_typed(self) -> list[CatalogEntry]:
        """Entry items re-validated as typed :class:`CatalogEntry` facades."""
        result = []
        for stub in self.items:
            typed = generated.CatalogEntryDTO1.model_validate(stub.root)
            result.append(CatalogEntry(typed))
        return result

    @property
    def next_page_token(self) -> str | None:
        """Token for the next page, or ``None`` on the last page."""
        return self.raw.nextPageToken

    @property
    def total_items_count(self) -> int | None:
        """Total entry count (present only when ``calculateTotalItemsCount`` was requested)."""
        return self.raw.totalItemsCount

    @classmethod
    def from_dict(cls, data: dict) -> CatalogEntryList:  # type: ignore[type-arg]
        """Parse from a raw API response dict."""
        return cls(generated.ListPostDefinitionCatalogEntriesResponseDTO.model_validate(data))

items property

Raw entry items (generated stubs).

items_typed property

Entry items re-validated as typed :class:CatalogEntry facades.

next_page_token property

Token for the next page, or None on the last page.

total_items_count property

Total entry count (present only when calculateTotalItemsCount was requested).

from_dict(data) classmethod

Parse from a raw API response dict.

Source code in src/pynteracta/models/facade/catalogs.py 
194
195
196
197
@classmethod
def from_dict(cls, data: dict) -> CatalogEntryList:  # type: ignore[type-arg]
    """Parse from a raw API response dict."""
    return cls(generated.ListPostDefinitionCatalogEntriesResponseDTO.model_validate(data))

pynteracta.models.facade.catalogs.CatalogEntry

Narrow facade over :class:~generated.CatalogEntryDTO1.

Attributes:

Name Type Description
raw

The underlying generated DTO.
Source code in src/pynteracta/models/facade/catalogs.py 
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
class CatalogEntry:
    """Narrow facade over :class:`~generated.CatalogEntryDTO1`.

    Attributes:
        raw: The underlying generated DTO.
    """

    def __init__(self, raw: generated.CatalogEntryDTO1) -> None:
        self.raw = raw

    @property
    def id(self) -> int | None:
        """Unique entry identifier."""
        return self.raw.id

    @property
    def label(self) -> str | None:
        """Entry label (display value)."""
        return self.raw.label

    @property
    def external_id(self) -> str | None:
        """External identifier for this entry."""
        return self.raw.externalId

    @property
    def parent_ids(self) -> list[int] | None:
        """Parent entry identifiers (for hierarchical catalogs)."""
        return self.raw.parentIds

    @property
    def catalog_id(self) -> int | None:
        """Id del catalogo a cui appartiene la voce."""
        return self.raw.catalogId

    @property
    def deleted(self) -> bool | None:
        """Se la voce è disabilitata (cancellazione logica)."""
        return self.raw.deleted

    @classmethod
    def from_raw(cls, raw: generated.CatalogEntryDTO1) -> CatalogEntry:
        """Wrap a generated DTO."""
        return cls(raw)

    @classmethod
    def from_stub(cls, stub: generated.CatalogEntryDTO) -> CatalogEntry:
        """Rivalida uno stub ``CatalogEntryDTO`` in :class:`CatalogEntry`."""
        root = _resolve_root(stub)
        if isinstance(root, dict):
            return cls(generated.CatalogEntryDTO1.model_validate(root))
        msg = f"Unexpected stub root type: {type(root)}"
        raise ValueError(msg)

catalog_id property

Id del catalogo a cui appartiene la voce.

deleted property

Se la voce è disabilitata (cancellazione logica).

external_id property

External identifier for this entry.

id property

Unique entry identifier.

label property

Entry label (display value).

parent_ids property

Parent entry identifiers (for hierarchical catalogs).

from_raw(raw) classmethod

Wrap a generated DTO.

Source code in src/pynteracta/models/facade/catalogs.py 
145
146
147
148
@classmethod
def from_raw(cls, raw: generated.CatalogEntryDTO1) -> CatalogEntry:
    """Wrap a generated DTO."""
    return cls(raw)

from_stub(stub) classmethod

Rivalida uno stub CatalogEntryDTO in :class:CatalogEntry.

Source code in src/pynteracta/models/facade/catalogs.py 
150
151
152
153
154
155
156
157
@classmethod
def from_stub(cls, stub: generated.CatalogEntryDTO) -> CatalogEntry:
    """Rivalida uno stub ``CatalogEntryDTO`` in :class:`CatalogEntry`."""
    root = _resolve_root(stub)
    if isinstance(root, dict):
        return cls(generated.CatalogEntryDTO1.model_validate(root))
    msg = f"Unexpected stub root type: {type(root)}"
    raise ValueError(msg)

pynteracta.models.facade.catalogs.CatalogWriteResult

Façade sulla risposta di catalogs.create ed catalogs.edit (spec 06).

Attributes:

Name Type Description
raw

Il DTO generato CreateEditCatalogResponseDTO.
Source code in src/pynteracta/models/facade/catalogs.py 
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
class CatalogWriteResult:
    """Façade sulla risposta di ``catalogs.create`` ed ``catalogs.edit`` (spec 06).

    Attributes:
        raw: Il DTO generato ``CreateEditCatalogResponseDTO``.
    """

    def __init__(
        self, raw: generated.CreateEditCatalogResponseDTO, *, catalog_id: int | None = None
    ) -> None:
        self.raw = raw
        self._catalog_id = catalog_id

    @property
    def catalog(self) -> Catalog | None:
        """Il catalogo scritto, come restituito dal server."""
        return Catalog.from_stub(self.raw.catalog) if self.raw.catalog is not None else None

    @property
    def parent_catalog(self) -> Catalog | None:
        """Il catalogo parent, se c'è."""
        parent = self.raw.parentCatalog
        return Catalog.from_stub(parent) if parent is not None else None

    @property
    def catalog_id(self) -> int | None:
        """Id del catalogo: dalla risposta, altrimenti quello passato dal chiamante."""
        catalog = self.catalog
        if catalog is not None and catalog.id is not None:
            return catalog.id
        return self._catalog_id

    @property
    def next_occ_token(self) -> int | None:
        """Token di concorrenza da usare per la modifica successiva."""
        return self.raw.occToken

    @classmethod
    def from_dict(cls, data: dict[str, Any], catalog_id: int | None = None) -> CatalogWriteResult:
        """Legge la risposta grezza; ``catalog_id`` completa le risposte senza catalogo."""
        return cls(
            generated.CreateEditCatalogResponseDTO.model_validate(data), catalog_id=catalog_id
        )

catalog property

Il catalogo scritto, come restituito dal server.

catalog_id property

Id del catalogo: dalla risposta, altrimenti quello passato dal chiamante.

next_occ_token property

Token di concorrenza da usare per la modifica successiva.

parent_catalog property

Il catalogo parent, se c'è.

from_dict(data, catalog_id=None) classmethod

Legge la risposta grezza; catalog_id completa le risposte senza catalogo.

Source code in src/pynteracta/models/facade/catalogs.py 
237
238
239
240
241
242
@classmethod
def from_dict(cls, data: dict[str, Any], catalog_id: int | None = None) -> CatalogWriteResult:
    """Legge la risposta grezza; ``catalog_id`` completa le risposte senza catalogo."""
    return cls(
        generated.CreateEditCatalogResponseDTO.model_validate(data), catalog_id=catalog_id
    )

pynteracta.models.facade.catalogs.CatalogEntryWriteResult

Façade sulla risposta di catalogs.create_entry ed catalogs.edit_entry (spec 06).

Attributes:

Name Type Description
raw

Il DTO generato CreateEditCatalogEntryResponseDTO.
Source code in src/pynteracta/models/facade/catalogs.py 
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
class CatalogEntryWriteResult:
    """Façade sulla risposta di ``catalogs.create_entry`` ed ``catalogs.edit_entry`` (spec 06).

    Attributes:
        raw: Il DTO generato ``CreateEditCatalogEntryResponseDTO``.
    """

    def __init__(
        self,
        raw: generated.CreateEditCatalogEntryResponseDTO,
        *,
        catalog_id: int | None = None,
        entry_id: int | None = None,
    ) -> None:
        self.raw = raw
        self._catalog_id = catalog_id
        self._entry_id = entry_id

    @property
    def entry(self) -> CatalogEntry | None:
        """La voce scritta, come restituita dal server."""
        return CatalogEntry.from_stub(self.raw.entry) if self.raw.entry is not None else None

    @property
    def catalog_id(self) -> int | None:
        """Id del catalogo: dalla voce restituita, altrimenti quello passato."""
        entry = self.entry
        if entry is not None and entry.catalog_id is not None:
            return entry.catalog_id
        return self._catalog_id

    @property
    def entry_id(self) -> int | None:
        """Id della voce: dalla risposta, altrimenti quello passato."""
        entry = self.entry
        if entry is not None and entry.id is not None:
            return entry.id
        return self._entry_id

    @property
    def next_occ_token(self) -> int | None:
        """Token di concorrenza da usare per la modifica successiva."""
        return self.raw.occToken

    @classmethod
    def from_dict(
        cls, data: dict[str, Any], catalog_id: int | None, entry_id: int | None = None
    ) -> CatalogEntryWriteResult:
        """Legge la risposta grezza; gli id completano le risposte senza voce."""
        return cls(
            generated.CreateEditCatalogEntryResponseDTO.model_validate(data),
            catalog_id=catalog_id,
            entry_id=entry_id,
        )

catalog_id property

Id del catalogo: dalla voce restituita, altrimenti quello passato.

entry property

La voce scritta, come restituita dal server.

entry_id property

Id della voce: dalla risposta, altrimenti quello passato.

next_occ_token property

Token di concorrenza da usare per la modifica successiva.

from_dict(data, catalog_id, entry_id=None) classmethod

Legge la risposta grezza; gli id completano le risposte senza voce.

Source code in src/pynteracta/models/facade/catalogs.py 
289
290
291
292
293
294
295
296
297
298
@classmethod
def from_dict(
    cls, data: dict[str, Any], catalog_id: int | None, entry_id: int | None = None
) -> CatalogEntryWriteResult:
    """Legge la risposta grezza; gli id completano le risposte senza voce."""
    return cls(
        generated.CreateEditCatalogEntryResponseDTO.model_validate(data),
        catalog_id=catalog_id,
        entry_id=entry_id,
    )

pynteracta.models.facade.catalogs.CatalogDeletedResult

Façade sulla risposta di set_deleted e set_entry_deleted (spec 06).

Lo swagger dichiara per entrambi gli endpoint la risposta del catalogo (catalogId) ma definisce anche un DTO con entryId: la façade legge l'id presente e completa l'altro con quello passato dal chiamante.

Attributes:

Name Type Description
raw

EditCatalogDeletedResponseDTO o EditCatalogEntryDeletedResponseDTO.
Source code in src/pynteracta/models/facade/catalogs.py 
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
class CatalogDeletedResult:
    """Façade sulla risposta di ``set_deleted`` e ``set_entry_deleted`` (spec 06).

    Lo swagger dichiara per entrambi gli endpoint la risposta del catalogo (``catalogId``) ma
    definisce anche un DTO con ``entryId``: la façade legge l'id presente e completa l'altro con
    quello passato dal chiamante.

    Attributes:
        raw: ``EditCatalogDeletedResponseDTO`` o ``EditCatalogEntryDeletedResponseDTO``.
    """

    def __init__(
        self,
        raw: generated.EditCatalogDeletedResponseDTO | generated.EditCatalogEntryDeletedResponseDTO,
        *,
        catalog_id: int | None = None,
        entry_id: int | None = None,
    ) -> None:
        self.raw = raw
        self._catalog_id = catalog_id
        self._entry_id = entry_id

    @property
    def catalog_id(self) -> int | None:
        """Id del catalogo: dalla risposta, altrimenti quello passato."""
        value: int | None = getattr(self.raw, "catalogId", None)
        return value if value is not None else self._catalog_id

    @property
    def entry_id(self) -> int | None:
        """Id della voce (``None`` per un catalogo): dalla risposta, altrimenti quello passato."""
        value: int | None = getattr(self.raw, "entryId", None)
        return value if value is not None else self._entry_id

    @property
    def deleted(self) -> bool | None:
        """Il valore del flag ``deleted`` dopo la scrittura."""
        return self.raw.deleted

    @classmethod
    def from_dict(
        cls, data: dict[str, Any], catalog_id: int | None, entry_id: int | None = None
    ) -> CatalogDeletedResult:
        """Sceglie il DTO dalla chiave presente (``entryId`` o ``catalogId``)."""
        raw: generated.EditCatalogDeletedResponseDTO | generated.EditCatalogEntryDeletedResponseDTO
        if "entryId" in data:
            raw = generated.EditCatalogEntryDeletedResponseDTO.model_validate(data)
        else:
            raw = generated.EditCatalogDeletedResponseDTO.model_validate(data)
        return cls(raw, catalog_id=catalog_id, entry_id=entry_id)

catalog_id property

Id del catalogo: dalla risposta, altrimenti quello passato.

deleted property

Il valore del flag deleted dopo la scrittura.

entry_id property

Id della voce (None per un catalogo): dalla risposta, altrimenti quello passato.

from_dict(data, catalog_id, entry_id=None) classmethod

Sceglie il DTO dalla chiave presente (entryId o catalogId).

Source code in src/pynteracta/models/facade/catalogs.py 
340
341
342
343
344
345
346
347
348
349
350
@classmethod
def from_dict(
    cls, data: dict[str, Any], catalog_id: int | None, entry_id: int | None = None
) -> CatalogDeletedResult:
    """Sceglie il DTO dalla chiave presente (``entryId`` o ``catalogId``)."""
    raw: generated.EditCatalogDeletedResponseDTO | generated.EditCatalogEntryDeletedResponseDTO
    if "entryId" in data:
        raw = generated.EditCatalogEntryDeletedResponseDTO.model_validate(data)
    else:
        raw = generated.EditCatalogDeletedResponseDTO.model_validate(data)
    return cls(raw, catalog_id=catalog_id, entry_id=entry_id)