class Domain(Base):
    __tablename__ = "domains"
   
    domain_name: Mapped[str] = mapped_column(String, primary_key=True, index=True)

@Entity
@Table(name = "domains",
    indexes = {@Index(columnList = "name")})
@AllArgsConstructor
@NoArgsConstructor
@Getter
public class Domain {
    @Id
    @Column(name = "name",
        unique = true,
        nullable = false,
        columnDefinition = "TEXT")
    private String name;
}

class Website(Base):
    __tablename__ = "websites"

    url: Mapped[str] = mapped_column(String, primary_key=True, index=True)

    domain_name: Mapped[str] = mapped_column(
        ForeignKey("domains.domain_name"),
        index=True,
    )
    domain: Mapped[Domain] = relationship()

    ...

@Entity
@Table(name = "pages",
       indexes = {@Index(columnList = "url"),
                  @Index(columnList = "domain_name"),
                  ...})
@AllArgsConstructor
@NoArgsConstructor
@Getter
@Builder
public class Page {
    @Id
    @Column(name = "url",
            nullable = false,
            columnDefinition = "TEXT")
    private String url;


    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "domain_name",
                nullable = false)
    private Domain domain;

    ...
}

class VerifiedDomain(Base):
    __tablename__ = "verified_domains"

    user_id: Mapped[int] = mapped_column(
        ForeignKey("users.id"),
        primary_key=True,
        index=True,
    )
    user: Mapped[User] = relationship()

    domain_name: Mapped[str] = mapped_column(
        String,
        primary_key=True,
        index=True,
    )

    is_verified: Mapped[bool] = mapped_column(Boolean)
    verification_code: Mapped[str] = mapped_column(String)
    


class VerifiedDomainsService:
    ...
    
    async def create_verified_domain(
        self,
        db: AsyncSession,
        domain_name: str,
        user_id: int,
    ) -> models.VerifiedDomain:
        verified_domain = models.VerifiedDomain()
        verified_domain.user_id = user_id
        verified_domain.domain_name = domain_name
        verified_domain.is_verified = False
        verified_domain.verification_code = str(uuid4())
        db.add(verified_domain)
        await db.commit()
        await db.refresh(verified_domain)
        return verified_domain

@Entity
@Getter
@Table(name = "verified_domains",
    indexes = {@Index(columnList = "user_id, domain_name")})
@AllArgsConstructor
@NoArgsConstructor
public class VerifiedDomain {
    @Id
    @GeneratedValue
    @Column(name = "id")
    private Long id;

    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "user_id",
        nullable = false)
    private User user;

    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "domain_name",
        nullable = false)
    private Domain domain;

    @Setter
    @Column(name = "is_verified")
    private boolean isVerified;

    @Column(name = "verification_code")
    private String verificationCode;
}

@Service
@RequiredArgsConstructor
public class VerifiedDomainService {
    ...
      
    private VerifiedDomain createVerifiedDomain(User user, Domain domain) {
        VerifiedDomain verifiedDomain =
            this.verifiedDomainRepository.findVerifiedDomainByUserAndDomain(user, domain);

        if (verifiedDomain != null) {
            throw new IllegalArgumentException("Domain already exists");
        }

        verifiedDomain = new VerifiedDomain(null,
                                            user,
                                            domain,
                                            false,
                                            UUID.randomUUID()
                                                .toString());
        return this.verifiedDomainRepository.save(verifiedDomain);
    }
}

class WebsiteSubscriptionsService(...):
    ...
    
    async def add_website_subscription(
        ...
    ) -> schemas.WebsiteCreationResponse:
        ...

        ALLOWED_WEBSITES_COUNT_WITHOUT_VERIFICATION = 10
        if same_domain_websites_count >= ALLOWED_WEBSITES_COUNT_WITHOUT_VERIFICATION:
            is_domain_verified = (
                await self._verified_domains_service.is_domain_verified(
                    db,
                    user,
                    website.domain_name,
                )
            )

            if not is_domain_verified:
                raise HTTPException(
                    status.HTTP_400_BAD_REQUEST,
                    "domain_verification_needed",
                )

        ...

@Service
@RequiredArgsConstructor
public class PageSubscriptionService {
    ...
      
    public PageSubscription addPageSubscription(...) throws ... {
        ...
          
        long sameDomainPagesCount = this.pageService.getDomainPagesCount(loweredUrl);
        if (sameDomainPagesCount > ALLOWED_WEBSITES_COUNT_WITHOUT_VERIFICATION) {
            boolean isDomainVerified =
                this.verifiedDomainService.isDomainVerified(user, loweredUrl);

            if (!isDomainVerified) {
                throw new ResponseStatusException(HttpStatus.BAD_REQUEST,
                                                  "domain_verification_needed");
            }
        }
        
        ...
    }

...
import dns.resolver
...

class VerifyDomainCommand:
    async def verify_domain(
        self,
        verified_domain: models.VerifiedDomain,
    ) -> bool:
        if await asyncio.to_thread(
            self._is_domain_has_code_in_txt_record,
            verified_domain.domain_name,
            verified_domain.verification_code,
        ):
            return True

        ...

        return False

    ...

    def _is_domain_has_code_in_txt_record(
        self,
        domain_name: str,
        code: str,
    ) -> bool:
        try:
            resolved_records = dns.resolver.resolve(
                domain_name,
                "TXT",
            )

            if not resolved_records or not resolved_records.rrset:
                return False

            txt_records = [
                dns_record.to_text() for dns_record in resolved_records.rrset
            ]

            return any(code in txt_record for txt_record in txt_records)
        except Exception as e:
            ...
            return False

...
import org.xbill.DNS.Lookup;
import org.xbill.DNS.Record;
import org.xbill.DNS.TextParseException;
import org.xbill.DNS.Type;
...

public class VerifyDomainCommand {
    public boolean verifyDomain(VerifiedDomain verifiedDomain) {
        String domainName = verifiedDomain.getDomain()
            .getName();
        String verificationCode = verifiedDomain.getVerificationCode();

        boolean isDomainTxtVerified = this.isDomainHasCodeInTxtRecord(domainName, verificationCode);
        if (isDomainTxtVerified) {
            return true;
        }

        ....
    }

    ...

    private boolean isDomainHasCodeInTxtRecord(String domainName, String code) {
        try {
            Record[] records = new Lookup(domainName, Type.TXT).run();

            if (records == null) {
                return false;
            }

            for (Record record : records) {
                String txt = record.rdataToString();

                if (txt.contains(code)) {
                    return true;
                }
            }
        } catch (TextParseException e) {
            // ignore, because domain may not exist
        }

        return false;
    }
}

...
import aiohttp
...

class VerifyDomainCommand:
    async def verify_domain(
        self,
        verified_domain: models.VerifiedDomain,
    ) -> bool:
        ...

        if await self._is_verification_file_present(
            verified_domain.domain_name,
            verified_domain.verification_code,
        ):
            return True

        return False

    async def _is_verification_file_present(
        self,
        domain_name: str,
        code: str,
    ) -> bool:
        session_timeout = aiohttp.ClientTimeout(
            total=None,
            sock_connect=20,
            sock_read=20,
        )

        async with aiohttp.ClientSession(timeout=session_timeout) as session:
            try:
                verification_page_response = await session.get(
                    f"https://{domain_name}/monitoring-verification",
                    headers={"User-Agent": "proverator.ru"},
                )

                if verification_page_response.status != HTTPStatus.OK:
                    raise Exception("Status is not OK")
                if code not in await verification_page_response.text():
                    raise Exception("Code has not been found")
            except Exception:
                try:
                    verification_page_response = await session.get(
                        f"http://{domain_name}/monitoring-verification",
                        headers={"User-Agent": "proverator.ru"},
                    )

                    if verification_page_response.status != HTTPStatus.OK:
                        raise Exception("Status is not OK")
                    if code not in await verification_page_response.text():
                        raise Exception("Code has not been found")
                except Exception:
                    return False

        return True

    ...

public class VerifyDomainCommand {
    public boolean verifyDomain(VerifiedDomain verifiedDomain) {
        ...

        return this.isVerificationFilePresent(verifiedDomain.getDomain()
                                                  .getName(),
                                              verifiedDomain.getVerificationCode());
    }

    private boolean isVerificationFilePresent(String domainName, String code) {
        try {
            String url = "https://" + domainName + "/monitoring-verification";
            if (this.checkVerificationPage(url, code)) {
                return true;
            }
        } catch (Exception e) {
            try {
                String url = "http://" + domainName + "/monitoring-verification";
                if (this.checkVerificationPage(url, code)) {
                    return true;
                }
            } catch (Exception ignored) {
                // domain may not exist
            }
        }

        return false;
    }

    private boolean checkVerificationPage(String urlString, String code) {
        try (HttpClient client = HttpClient.newHttpClient()) {
            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(urlString))
                .header("User-Agent", "proverator.ru")
                .build();

            CompletableFuture<HttpResponse<String>> response =
                client.sendAsync(request, HttpResponse.BodyHandlers.ofString());
            String responseBody = response.thenApply(HttpResponse::body)
                .get();

            return responseBody.contains(code);
        } catch (Exception e) {
            return false;
        }
    }

    ...
}