cloudfloordns.models.domain

  1# from dataclasses import dataclass, field
  2import datetime
  3import logging
  4from collections import ChainMap
  5from typing import Any, List, Literal, Optional
  6
  7from pydantic import AliasChoices, BaseModel, ConfigDict, Field, field_validator
  8
  9from cloudfloordns.constants import NS1, NS2, NS3, NS4
 10
 11
 12class DomainDescription(BaseModel):
 13    """
 14    Pydantic model
 15    """
 16
 17    status: Optional[str]
 18    status_extended: Optional[str]
 19
 20    class Config:
 21        extra = "allow"
 22
 23
 24class Contact(BaseModel):
 25    """
 26    Pydantic model
 27    """
 28
 29    firstname: Optional[str] = Field(alias="FirstName", default=None)
 30    lastname: Optional[str] = Field(alias="LastName", default=None)
 31    companyname: Optional[str] = Field(alias="Organization", default=None)
 32    streetaddress: Optional[str] = Field(alias="Address", default=None)
 33    city: Optional[str] = Field(alias="City", default=None)
 34    state: Optional[str] = Field(alias="State", default=None)
 35    postalcode: Optional[str] = Field(alias="PostalCode", default=None)
 36    country: Optional[str] = Field(alias="Country", default=None)
 37    phone: Optional[str] = Field(alias="Phone", default=None)
 38    fax: Optional[str] = Field(alias="Fax", default=None)
 39    email: Optional[str] = Field(alias="Email", default=None)
 40
 41    class Config:
 42        populate_by_name = True
 43        extra = "ignore"
 44
 45    def dump_as(self, prefix, by_alias=False):
 46        prefix = prefix.title() if by_alias else prefix.lower()
 47        return {
 48            f"{prefix}{k}": v for k, v in self.model_dump(by_alias=by_alias).items()
 49        }
 50
 51    def as_owner(self, by_alias=False):
 52        return self.dump_as("owner", by_alias=by_alias)
 53
 54    def as_admin(self, by_alias=False):
 55        return self.dump_as("admin", by_alias=by_alias)
 56
 57    def as_tech(self, by_alias=False):
 58        return self.dump_as("tech", by_alias=by_alias)
 59
 60    def as_bill(self, by_alias=False):
 61        return self.dump_as("bill", by_alias=by_alias)
 62
 63
 64class DomainPayload(BaseModel):
 65    """
 66    Pydantic model
 67    """
 68
 69    domainname: str
 70    organisation: Optional[str] = Field(default=None, alias="DomainOrganization")
 71
 72    # Owner informations
 73    ownerfirstname: str = Field(alias="OwnerFirstName")
 74    ownerlastname: str = Field(alias="OwnerLastName")
 75    ownercompanyname: str = Field(alias="OwnerOrganization")
 76    ownerstreetaddress: str = Field(alias="OwnerAddress")
 77    ownercity: str = Field(alias="OwnerCity")
 78    ownerstate: str = Field(alias="OwnerState")
 79    ownerpostalcode: str = Field(alias="OwnerPostalCode")
 80    ownercountry: str = Field(alias="OwnerCountry")
 81    ownerphone: str = Field(alias="OwnerPhone")
 82    ownerfax: str = Field(alias="OwnerFax")
 83    owneremail: str = Field(alias="OwnerEmail")
 84
 85    # Admin informations
 86    adminfirstname: str = Field(alias="AdminFirstName")
 87    adminlastname: str = Field(alias="AdminLastName")
 88    admincompanyname: str = Field(alias="AdminOrganization")
 89    adminstreetaddress: str = Field(alias="AdminAddress")
 90    admincity: str = Field(alias="AdminCity")
 91    adminstate: str = Field(alias="AdminState")
 92    adminpostalcode: str = Field(alias="AdminPostalCode")
 93    admincountry: str = Field(alias="AdminCountry")
 94    adminphone: str = Field(alias="AdminPhone")
 95    adminfax: str = Field(alias="AdminFax")
 96    adminemail: str = Field(alias="AdminEmail")
 97
 98    # Billing Contact informations
 99    billfirstname: str = Field(alias="BillFirstName")
100    billlastname: str = Field(alias="BillLastName")
101    billcompanyname: str = Field(alias="BillOrganization")
102    billstreetaddress: str = Field(alias="BillAddress")
103    billcity: str = Field(alias="BillCity")
104    billstate: str = Field(alias="BillState")
105    billpostalcode: str = Field(alias="BillPostalCode")
106    billcountry: str = Field(alias="BillCountry")
107    billphone: str = Field(alias="BillPhone")
108    billfax: str = Field(alias="BillFax")
109    billemail: str = Field(alias="BillEmail")
110
111    # Technical Contact informations
112    techfirstname: str = Field(alias="TechFirstName")
113    techlastname: str = Field(alias="TechLastName")
114    techcompanyname: str = Field(alias="TechOrganization")
115    techstreetaddress: str = Field(alias="TechAddress")
116    techcity: str = Field(alias="TechCity")
117    techstate: str = Field(alias="TechState")
118    techcountry: str = Field(alias="TechCountry")
119    techpostalcode: str = Field(alias="TechPostalCode")
120    techphone: str = Field(alias="TechPhone")
121    techfax: str = Field(alias="TechFax")
122    techemail: str = Field(alias="TechEmail")
123
124    # Other informations
125    groups_ids: List[str] = Field(default_factory=list)
126    assign_default_groups_nameserver: Literal[0, 1] = 1
127    autorenew: Optional[str] = Field(
128        validation_alias=AliasChoices("auto_renew", "autorenew"), default=None
129    )
130    reg_opt_out: Optional[str] = None
131    nom_type: Optional[str] = None
132    lock: Optional[str] = Field(
133        validation_alias=AliasChoices("lock", "locked"), default=None
134    )
135
136    domain_ns1: Optional[str] = Field(alias="DomainNS1", default=NS1)
137    domain_ns2: Optional[str] = Field(alias="DomainNS2", default=NS2)
138    domain_ns3: Optional[str] = Field(alias="DomainNS3", default=NS3)
139    domain_ns4: Optional[str] = Field(alias="DomainNS4", default=NS4)
140    domain_ns1_ip: Optional[str] = Field(alias="DomainNS1IP", default=None)
141    domain_ns2_ip: Optional[str] = Field(alias="DomainNS2IP", default=None)
142    domain_ns3_ip: Optional[str] = Field(alias="DomainNS3IP", default=None)
143    domain_ns4_ip: Optional[str] = Field(alias="DomainNS4IP", default=None)
144
145    @field_validator("lock", mode="before")
146    @classmethod
147    def ensure_locked_as_string(cls, v: Any):
148        if not isinstance(v, str):
149            return str(v)
150        return v
151
152    def _setcontact(self, prefix, info: Contact):
153        data = info.dump_as(prefix)
154        for k, v in data.items():
155            setattr(self, k, v)
156        # Domain.model_validate(self)
157        return self
158
159    def set_owner(self, info: Contact):
160        return self._setcontact("Owner", info)
161
162    def set_admin(self, info: Contact):
163        return self._setcontact("Admin", info)
164
165    def set_bill(self, info: Contact):
166        return self._setcontact("Bill", info)
167
168    def set_tech(self, info: Contact):
169        return self._setcontact("Tech", info)
170
171    @classmethod
172    def prepare(
173        cls,
174        domainname: str,
175        owner: Contact,
176        admin: Contact,
177        bill: Contact,
178        tech: Contact,
179    ) -> "DomainPayload":
180        contact_data = {
181            k: v
182            for prefix, c in (
183                ("Owner", owner),
184                ("Admin", admin),
185                ("Bill", bill),
186                ("Tech", tech),
187            )
188            for k, v in c.dump_as(prefix).items()
189        }
190        return cls.model_validate({"domainname": domainname, **contact_data})
191
192    def dump_for_update(self):
193        payload = self.model_dump(
194            by_alias=True,
195            exclude=[
196                "domainname",
197                # "domain_ns1",
198                # "domain_ns2",
199            ],
200            exclude_none=True,
201            exclude_unset=True,
202        )
203        payload = {
204            k: v for k, v in payload.items() if not k.lower().startswith("owner")
205        }
206        payload = {k: v for k, v in payload.items() if not k.lower().endswith("fax")}
207        return payload
208
209    # https://docs.pydantic.dev/latest/concepts/config/
210    # https://docs.pydantic.dev/latest/api/config/#pydantic.config.ConfigDict.validate_assignment
211    model_config = ConfigDict(
212        populate_by_name=True,
213        extra="ignore",
214        validate_assignment=True,
215    )
216
217
218CLOUDFLOORDNS_NAMESERVERS = (
219    "dns1.name-s.net.",
220    "dns2.name-s.net.",
221    "dns0.mtgsy.com.",
222    "dns3.mtgsy.com.",
223    "dns4.mtgsy.com.",
224    "ns1.g02.cfdns.net.",
225    "ns1.g02.cfdns.net.",
226    "ns2.g02.cfdns.biz.",
227    "ns3.g02.cfdns.info.",
228    "ns4.g02.cfdns.co.uk.",
229)
230CLOUDFLOORDNS_NAMESERVERS_DOMAINS = (
231    "name-s.net.",
232    "mtgsy.com.",
233    "cfdns.net.",
234    "cfdns.net.",
235    "cfdns.biz.",
236    "cfdns.info.",
237    "cfdns.co.uk.",
238)
239
240
241def is_cloudlfoordns_ns(ns):
242    # Ensure the nameserver ends with a single dot.
243    ns = ns.strip().rstrip(".").lower() + "."
244    return ns.endswith(CLOUDFLOORDNS_NAMESERVERS_DOMAINS)
245
246
247class Domain(BaseModel):
248    """
249    Pydantic model
250    """
251
252    model_config = ConfigDict(
253        populate_by_name=True,
254        extra="allow",
255        # https://docs.pydantic.dev/latest/concepts/pydantic_settings/#case-sensitivity
256        # case_sensitive = True
257        # https://docs.pydantic.dev/latest/api/config/#pydantic.config.ConfigDict.validate_assignment
258        validate_assignment=True,
259    )
260
261    domainname: str = Field(validation_alias=AliasChoices("domainname", "domain"))
262
263    id: Optional[str] = None
264    epp: Optional[str] = Field(default=None, alias="EPP")
265    organisation: Optional[str] = None
266
267    # Owner informations
268    ownerfirstname: Optional[str] = Field(default=None, alias="OwnerFirstName")
269    ownerlastname: Optional[str] = Field(default=None, alias="OwnerLastName")
270    ownercompanyname: Optional[str] = Field(default=None, alias="OwnerOrganization")
271    ownerstreetaddress: Optional[str] = Field(default=None, alias="OwnerAddress")
272    ownercity: Optional[str] = Field(default=None, alias="OwnerCity")
273    ownerstate: Optional[str] = Field(default=None, alias="OwnerState")
274    ownerpostalcode: Optional[str] = Field(default=None, alias="OwnerPostalCode")
275    ownercountry: Optional[str] = Field(default=None, alias="OwnerCountry")
276    ownerphone: Optional[str] = Field(default=None, alias="OwnerPhone")
277    ownerfax: Optional[str] = Field(default=None, alias="OwnerFax")
278    owneremail: Optional[str] = Field(default=None, alias="OwnerEmail")
279
280    # Admin informations
281    adminfirstname: Optional[str] = Field(default=None, alias="AdminFirstName")
282    adminlastname: Optional[str] = Field(default=None, alias="AdminLastName")
283    admincompanyname: Optional[str] = Field(default=None, alias="AdminOrganization")
284    adminstreetaddress: Optional[str] = Field(default=None, alias="AdminAddress")
285    admincity: Optional[str] = Field(default=None, alias="AdminCity")
286    adminstate: Optional[str] = Field(default=None, alias="AdminState")
287    adminpostalcode: Optional[str] = Field(default=None, alias="AdminPostalCode")
288    admincountry: Optional[str] = Field(default=None, alias="AdminCountry")
289    adminphone: Optional[str] = Field(default=None, alias="AdminPhone")
290    adminfax: Optional[str] = Field(default=None, alias="AdminFax")
291    adminemail: Optional[str] = Field(default=None, alias="AdminEmail")
292
293    # Billing Contact informations
294    billfirstname: Optional[str] = Field(default=None, alias="BillFirstName")
295    billlastname: Optional[str] = Field(default=None, alias="BillLastName")
296    billcompanyname: Optional[str] = Field(default=None, alias="BillOrganization")
297    billstreetaddress: Optional[str] = Field(default=None, alias="BillAddress")
298    billcity: Optional[str] = Field(default=None, alias="BillCity")
299    # There is a typo in the returned value.
300    billstate: Optional[str] = Field(
301        default=None,
302        alias="BillState",
303        validation_alias=AliasChoices("billState", "BillState"),
304    )
305    billpostalcode: Optional[str] = Field(default=None, alias="BillPostalCode")
306    billcountry: Optional[str] = Field(default=None, alias="BillCountry")
307    billphone: Optional[str] = Field(default=None, alias="BillPhone")
308    billfax: Optional[str] = Field(default=None, alias="BillFax")
309    billemail: Optional[str] = Field(default=None, alias="BillEmail")
310
311    # Technical Contact informations
312    techfirstname: Optional[str] = Field(default=None, alias="TechFirstName")
313    techlastname: Optional[str] = Field(default=None, alias="TechLastName")
314    techcompanyname: Optional[str] = Field(default=None, alias="TechOrganization")
315    techstreetaddress: Optional[str] = Field(default=None, alias="TechAddress")
316    techcity: Optional[str] = Field(default=None, alias="TechCity")
317    techstate: Optional[str] = Field(default=None, alias="TechState")
318    techcountry: Optional[str] = Field(default=None, alias="TechCountry")
319    techpostalcode: Optional[str] = Field(default=None, alias="TechPostalCode")
320    techphone: Optional[str] = Field(default=None, alias="TechPhone")
321    techfax: Optional[str] = Field(default=None, alias="TechFax")
322    techemail: Optional[str] = Field(default=None, alias="TechEmail")
323
324    # Other informations
325    auto_renew: Optional[str] = None
326    reg_opt_out: Optional[str] = None
327    username: Optional[str] = None
328    status: Optional[str] = None
329    use_trustee: Optional[str] = None
330    locked: Optional[str] = None
331    editzone: Optional[str] = None
332    expires: Optional[datetime.date] = None
333    deleteonexpiry: Optional[str] = None
334    companyregno: Optional[str] = None
335    client_delete_prohibited_lock: Optional[str] = None
336    client_update_prohibited_lock: Optional[str] = None
337    client_transfer_prohibited_lock: Optional[str] = None
338    registeredhere: Optional[str] = None
339    nameserver: List[str] = Field(default_factory=list)
340    domain_description: Optional[DomainDescription] = None
341
342    @property
343    def is_externally_managed(self):
344        is_cfdns_ns = [is_cloudlfoordns_ns(ns) for ns in self.nameserver]
345        if all(is_cfdns_ns):
346            return False
347        if not any(is_cfdns_ns):
348            return True
349        # Part of the nameserver are owned by CFDns, the rest is not
350        # => The nameserver configuration is wrong
351        ns_txt = ", ".join(self.nameserver)
352        logging.warning(
353            f"Domain {self.domainname} has inconsistant nameservers: {ns_txt}"
354        )
355        return False
356
357    @field_validator("locked", mode="before")
358    @classmethod
359    def ensure_locked_as_string(cls, v: Any):
360        if not isinstance(v, str):
361            return str(v)
362        return v
363
364    # @model_validator(mode='before')
365    # @classmethod
366    # def check_card_number_omitted(cls, data: Any) -> Any:
367    #     if isinstance(data, dict):
368    #         assert (
369    #             'card_number' not in data
370    #         ), 'card_number should not be included'
371    #     return data
372
373    def _setcontact(self, prefix, info: Contact):
374        data = info.dump_as(prefix)
375        for k, v in data.items():
376            setattr(self, k, v)
377        # Domain.model_validate(self)
378        return self
379
380    def _getcontact(self, prefix: str) -> Contact:
381        data = {k.removeprefix(prefix): v for k, v in self.model_dump().items()}
382        return Contact.model_validate(data)
383
384    def set_owner(self, info: Contact):
385        return self._setcontact("owner", info)
386
387    def set_admin(self, info: Contact):
388        return self._setcontact("admin", info)
389
390    def set_bill(self, info: Contact):
391        return self._setcontact("bill", info)
392
393    def set_tech(self, info: Contact):
394        return self._setcontact("tech", info)
395
396    def update_contact(
397        self,
398        owner: Optional[Contact] = None,
399        admin: Optional[Contact] = None,
400        tech: Optional[Contact] = None,
401        bill: Optional[Contact] = None,
402        timeout=None,
403    ):
404        converted = (
405            d
406            for d in (
407                owner and owner.as_owner(),
408                admin and admin.as_admin(),
409                tech and tech.as_tech(),
410                bill and bill.as_bill(),
411            )
412            if d
413        )
414        data = dict(ChainMap(*converted))
415        for k, v in data.items():
416            setattr(self, k, v)
417        # Domain.model_validate(self)
418        return self
419
420    def register_payload(self, use_default_ns: bool = True) -> DomainPayload:
421        data = self.model_dump(by_alias=True)
422        data.update(
423            {
424                # "groups_ids": ...,
425                "assign_default_groups_nameserver": 1 if use_default_ns else 0,
426            }
427        )
428
429        return DomainPayload.model_validate(data)
430
431    def dump_for_update(self):
432        return self.model_dump(
433            by_alias=True,
434            exclude=[
435                "epp",
436                "status",
437                "use_trustee",
438                "locked",
439                "domain_description",
440            ],
441        )