talentro-commons 0.1.1__tar.gz

talentro_commons-0.1.1/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.3
+Name: talentro-commons
+Version: 0.1.1
+Summary: This package contains all globally used code, services, models and data structures for Talentro
+License: Proprietary
+Author: Emiel van Essen
+Author-email: emiel@marksmen.nl
+Requires-Python: >=3.13
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: fastapi (>=0.116.0,<0.117.0)
+Requires-Dist: sqlalchemy (>=2.0.38,<3.0.0)
+Requires-Dist: sqlmodel (>=0.0.24,<0.0.25)
+Description-Content-Type: text/markdown
+
+# Talentro definitions
+
+This package contains all models and data structures for Talentro
+It is exclusively meant for the Talentro ecosystem.
+
+## Initial run
+
+- Run `poetry self update && poetry self add keyrings.google-artifactregistry-auth`
+- Run `poetry config repositories.gcp https://europe-west4-python.pkg.dev/talentro-459113/talentro-python`
+
+## How to create a new version
+
+- Make changes in the code, like editing the models
+- Bump the version number to desired version in `pyproject.toml` using the `major.minor.fix` format
+- run `poetry publish --build --repository gcp`
+
+Now a new version is uploaded to pypi and you can install it after a minute in the other projects.

talentro_commons-0.1.1/README.md

@@ -0,0 +1,17 @@
+# Talentro definitions
+
+This package contains all models and data structures for Talentro
+It is exclusively meant for the Talentro ecosystem.
+
+## Initial run
+
+- Run `poetry self update && poetry self add keyrings.google-artifactregistry-auth`
+- Run `poetry config repositories.gcp https://europe-west4-python.pkg.dev/talentro-459113/talentro-python`
+
+## How to create a new version
+
+- Make changes in the code, like editing the models
+- Bump the version number to desired version in `pyproject.toml` using the `major.minor.fix` format
+- run `poetry publish --build --repository gcp`
+
+Now a new version is uploaded to pypi and you can install it after a minute in the other projects.

talentro_commons-0.1.1/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "talentro-commons"
+version = "0.1.1"
+description = "This package contains all globally used code, services, models and data structures for Talentro"
+authors = [
+    { name = "Emiel van Essen", email = "emiel@marksmen.nl"}
+]
+license = { text = "Proprietary" }
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "sqlalchemy (>=2.0.38,<3.0.0)",
+    "sqlmodel (>=0.0.24,<0.0.25)",
+    "fastapi (>=0.116.0,<0.117.0)"
+]
+
+
+[tool.poetry]
+packages = [
+    {include = "talentro", from = "src"}
+]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

talentro_commons-0.1.1/src/talentro/billing/models.py

@@ -0,0 +1,26 @@
+from uuid import UUID
+
+from datetime import datetime, timezone
+from typing import Optional
+
+from sqlmodel import SQLModel, Field
+
+from ..general.models import BillingOrganizationModel
+
+
+class BillingEvent(SQLModel, table=True):
+    id: int = Field(
+        primary_key=True,
+    )
+
+    organization: UUID = Field(index=True)
+    event_time: Optional[datetime] = Field(
+        default_factory=lambda: datetime.now(timezone.utc),
+        nullable=False,
+    )
+    sku: str = Field(nullable=False)
+    count: int = Field(nullable=False, default=1)
+
+
+class BillingProfile(BillingOrganizationModel, table=True):
+    stripe_customer_id: str = Field(nullable=False)

talentro_commons-0.1.1/src/talentro/campaigns/dataclasses.py

@@ -0,0 +1,22 @@
+from datetime import datetime
+from typing import Optional
+from uuid import UUID
+
+from ..campaigns.models import ChannelType, CampaignGoal
+from ..general.models import BaseModel
+from ..integrations.dataclasses import Integration
+
+
+class Campaign(BaseModel):
+    id: UUID
+    created_at: datetime
+    updated_at: Optional[datetime]
+    organization: UUID
+    name: str
+    external_id: Optional[str]
+    status: str
+    last_sync_date: datetime
+    ad_count: int
+    channel: Integration
+    channel_type: ChannelType
+    campaign_goal: Optional[CampaignGoal]

talentro_commons-0.1.1/src/talentro/campaigns/models.py

@@ -0,0 +1,80 @@
+from uuid import UUID
+import enum
+
+from datetime import datetime
+from enum import StrEnum
+from typing import Optional
+
+from sqlalchemy import Column, JSON, Enum
+from sqlmodel import Field
+
+from ..general.models import CampaignsOrganizationModel
+
+
+class ChannelType(StrEnum):
+    JOB_BOARD = 'job-board'
+    SOCIAL = 'social'
+
+
+class CampaignGoal(enum.Enum):
+    REACH = 'reach'
+    TRAFFIC = 'traffic'
+    CONVERSION = 'conversion'
+    LEADS = 'leads'
+
+
+class Campaign(CampaignsOrganizationModel, table=True):
+    name: str = Field(index=True)
+    external_id: Optional[str] = Field(index=True)
+    status: str = Field(index=True)
+    last_sync_date: Optional[datetime] = Field()
+    ad_count: int = Field(default=0)
+    channel_id: UUID = Field(index=True)
+    channel_type: ChannelType = Field(sa_column=Column(Enum(ChannelType)))
+    campaign_goal: Optional[CampaignGoal] = Field(sa_column=Column(Enum(CampaignGoal)))
+
+
+class VacancySelection(CampaignsOrganizationModel):
+    campaign_id: UUID = Field(foreign_key="campaign.id")
+    feed_id: UUID = Field(index=True)
+    selection_criteria: dict = Field(sa_column=Column(JSON))
+
+
+class AdSet(CampaignsOrganizationModel, table=True):
+    name: str = Field(index=True)
+    external_id: Optional[str] = Field(index=True)
+    campaign_id: UUID = Field(foreign_key="campaign.id")
+    platforms: list = Field(sa_column=Column(JSON))
+    ad_types: list = Field(sa_column=Column(JSON))
+    settings: dict = Field(sa_column=Column(JSON))
+
+
+class TargetLocation(CampaignsOrganizationModel, table=True):
+    ad_set: UUID = Field(foreign_key="adset.id")
+    address: str = Field(index=True)
+    distance: int = Field(index=True)
+
+
+class TargetAudience(CampaignsOrganizationModel, table=True):
+    ad_set: UUID = Field(foreign_key="adset.id")
+    age_min: int = Field(index=True, default=18)
+    age_max: int = Field(index=True, default=150)
+    interests: list = Field(sa_column=Column(JSON))
+    languages: list = Field(sa_column=Column(JSON))
+
+
+class Ad(CampaignsOrganizationModel, table=True):
+    name: str = Field(index=True)
+    external_id: Optional[str] = Field(index=True)
+    campaign_id: UUID = Field(foreign_key="campaign.id")
+    ad_set_id: Optional[UUID] = Field(foreign_key="adset.id")
+    vacancy_id: Optional[UUID] = Field()
+    lead_form: Optional[UUID] = Field(foreign_key="leadform.id")
+    primary_text: str = Field()
+    title: str = Field()
+    description: Optional[str] = Field()
+    conversion_goal: Optional[str] = Field()
+
+
+class LeadForm(CampaignsOrganizationModel, table=True):
+    title: str = Field()

talentro_commons-0.1.1/src/talentro/candidates/dataclasses.py

@@ -0,0 +1,37 @@
+from datetime import datetime
+from typing import Optional
+from uuid import UUID
+
+from pydantic import BaseModel
+
+
+class CandidateData(BaseModel):
+    email: str
+    first_name: str
+    last_name: str
+    phone_number: str
+    hashed_email: str
+    cv: str
+    motivation_letter: str
+    linked_in: str
+
+
+class Candidate(CandidateData):
+    id: UUID
+    created_at: datetime
+    updated_at: Optional[datetime]
+    organization: UUID
+
+
+class ApplicationData(BaseModel):
+    status: str
+    source: str
+    candidate_id: str
+    vacancy_id: str
+
+
+class Application(ApplicationData):
+    id: UUID
+    created_at: datetime
+    updated_at: Optional[datetime]
+    organization: UUID

talentro_commons-0.1.1/src/talentro/constants.py

@@ -0,0 +1,28 @@
+from enum import StrEnum
+
+
+class ErrorCode(StrEnum):
+    UNKNOWN_ERROR = "UNKNOWN_ERROR"
+    NOT_AUTHENTICATED = "NOT_AUTHENTICATED"
+    NOT_FOUND = "NOT_FOUND"
+    BAD_REQUEST = "BAD_REQUEST"
+    ARGUMENT_ERROR = "ARGUMENT_ERROR"
+    NO_MEMBERSHIP = "NO_MEMBERSHIP"
+    PERMISSION_DENIED = "PERMISSION_DENIED"
+    ALREADY_EXISTS = "ALREADY_EXISTS"
+
+
+class DisplayMessage(StrEnum):
+    UNKNOWN_ERROR = "errors.unknownError"
+    NOT_AUTHENTICATED = "errors.notAuthenticated"
+    NOT_FOUND = "errors.notFound"
+    BAD_REQUEST = "errors.badRequest"
+    ARGUMENT_ERROR = "errors.argumentError"
+    PERMISSION_DENIED = "errors.noPermission"
+    NO_MEMBERSHIP = "errors.noMembership"
+    ALREADY_EXISTS = "errors.alreadyExists"
+
+
+class SKU(StrEnum):
+    SYNCED_VACANCY = 'synced_vacancy'
+

talentro_commons-0.1.1/src/talentro/event.py

@@ -0,0 +1,35 @@
+import json
+from dataclasses import dataclass
+from datetime import datetime
+from enum import StrEnum
+
+
+class Queue(StrEnum):
+    integrations = "integrations"
+    candidates = "candidates"
+    vacancies = "vacancies"
+    strategy = "strategy"
+    campaigns = "campaigns"
+    insights = "insights"
+    billing = "billing"
+    iam = "iam"
+    notifications = "notifications"
+    live_updates = "live-updates"
+
+
+@dataclass
+class Event:
+    event_type: str
+    payload: dict
+    organization_id: str | None = None
+    created_on: datetime = None
+
+    def encode(self) -> bytes:
+        self.created_on: datetime = datetime.now()
+        return json.dumps(self.__dict__, default=str).encode()
+
+
+@dataclass
+class Message:
+    event: Event
+    queue: Queue

talentro_commons-0.1.1/src/talentro/exceptions.py

@@ -0,0 +1,45 @@
+from http import HTTPStatus
+from typing import Any, Optional
+
+from fastapi import HTTPException
+
+
+class APIException(HTTPException):
+    def __init__(
+        self,
+        status_code: HTTPStatus,
+        error_code: str,
+        message: str,
+        display_message: str,
+        headers: Optional[dict[str, Any]] = None
+    ) -> None:
+        detail = {
+            "error_code": error_code,
+            "message": message,
+            "display_message": display_message
+        }
+
+        super().__init__(
+            status_code=status_code.value,
+            detail=detail,
+            headers=headers
+        )
+
+        self.status_code: HTTPStatus = status_code
+        self.error_code: str = error_code
+        self.message: str = message
+        self.display_message: str = display_message
+
+    def __str__(self):
+        return (
+            f"[{self.status_code}] {self.error_code}: {self.message} "
+            f"(Display: {self.display_message})"
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "status_code": self.status_code.value,
+            "error_code": self.error_code,
+            "message": self.message,
+            "display_message": self.display_message,
+        }

talentro_commons-0.1.1/src/talentro/general/models.py

@@ -0,0 +1,64 @@
+from uuid import UUID, uuid4
+
+from typing import Optional
+
+from sqlmodel import SQLModel, Field
+from datetime import datetime, timezone
+
+
+class BaseModel(SQLModel):
+    id: UUID = Field(default_factory=uuid4, primary_key=True)
+    created_at: Optional[datetime] = Field(
+        default_factory=lambda: datetime.now(timezone.utc)
+    )
+    updated_at: Optional[datetime] = Field(
+        default_factory=lambda: datetime.now(timezone.utc),
+        sa_column_kwargs = {"onupdate": lambda: datetime.now(timezone.utc)}
+    )
+
+
+# App specific models
+## Integrations
+class IntegrationsModel(BaseModel):
+    pass
+
+
+class IntegrationsOrganizationModel(IntegrationsModel):
+    organization: UUID = Field(index=True)
+
+
+## Vacancies
+class VacanciesModel(BaseModel):
+    pass
+
+
+class VacanciesOrganizationModel(VacanciesModel):
+    organization: UUID = Field(index=True)
+
+
+## Campaigns
+class CampaignsModel(BaseModel):
+    pass
+
+
+class CampaignsOrganizationModel(CampaignsModel):
+    organization: UUID = Field(index=True)
+
+
+
+## Billing
+class BillingModel(BaseModel):
+    pass
+
+
+class BillingOrganizationModel(BillingModel):
+    organization: UUID = Field(index=True)
+
+
+## IAM
+class IAMModel(BaseModel):
+    pass
+
+
+class IAMOrganizationModel(BaseModel):
+    organization: UUID = Field(index=True)

talentro_commons-0.1.1/src/talentro/iam/models.py

@@ -0,0 +1,19 @@
+from uuid import UUID
+
+from sqlmodel import Field
+
+from ..general.models import IAMModel, IAMOrganizationModel
+from sqlalchemy import Column, JSON
+
+
+class CompositeRole(IAMModel, table=True):
+    name: str = Field(index=True)
+    roles: list = Field(sa_column=Column(JSON))
+    organization: UUID = Field(index=True, nullable=True)
+    manageable_roles: list = Field(sa_column=Column(JSON))
+    permission_level: int = Field(default=0)
+
+
+class MemberRoleConnection(IAMOrganizationModel, table=True):
+    composite_role_id: UUID = Field(foreign_key="compositerole.id")
+    member: UUID = Field(index=True, nullable=False)

talentro_commons-0.1.1/src/talentro/iam/types.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass
+from typing import List
+
+@dataclass
+class Organization:
+    id: str
+    name: str
+    displayName: str
+    attributes: dict
+    roles: List[str]
+    url: str
+    role: str

talentro_commons-0.1.1/src/talentro/integrations/dataclasses.py

@@ -0,0 +1,34 @@
+from uuid import UUID
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class Integration(BaseModel):
+    id: UUID
+    created_at: datetime
+    updated_at: Optional[datetime]
+    organization: UUID
+
+    name: str
+    icon: str
+    type: str
+    tag: str
+    enabled: bool
+    description: str
+    code_reference: str
+    setup_config: dict
+    order: int
+
+
+class Link(BaseModel):
+    id: UUID
+    created_at: datetime
+    updated_at: Optional[datetime]
+    organization: UUID
+
+    name: str
+    status: str
+    auth_config: dict
+    integration_id: UUID

talentro_commons-0.1.1/src/talentro/integrations/models.py

@@ -0,0 +1,25 @@
+from uuid import UUID
+
+from sqlalchemy import Column, JSON
+from sqlmodel import Field
+
+from ..general.models import IntegrationsOrganizationModel, IntegrationsModel
+
+
+class Integration(IntegrationsModel, table=True):
+    name: str = Field(index=True)
+    icon: str = Field(index=True)
+    type: str = Field(index=True)
+    tag: str = Field(index=True, nullable=True)
+    enabled: bool = Field(default=True, nullable=True)
+    description: str = Field(index=True, nullable=True)
+    code_reference: str = Field(index=True)
+    setup_config: dict = Field(sa_column=Column(JSON))
+    order: int = Field(default=0)
+
+
+class Link(IntegrationsOrganizationModel, table=True):
+    name: str = Field(index=True)
+    status: str = Field(index=True)
+    auth_config: dict = Field(sa_column=Column(JSON))
+    integration_id: UUID = Field(foreign_key="integration.id")

talentro_commons-0.1.1/src/talentro/util/enum.py

@@ -0,0 +1,6 @@
+def to_enum(enum_cls, value):
+    if value is None:
+        return None
+    if isinstance(value, enum_cls):
+        return value
+    return enum_cls(value)

talentro_commons-0.1.1/src/talentro/vacancies/dataclasses.py

@@ -0,0 +1,172 @@
+from datetime import datetime
+from typing import List, Optional
+from uuid import UUID
+from dataclasses import field
+
+from pydantic import BaseModel
+
+from ..util.enum import to_enum
+from ..vacancies.models import Feed, Vacancy as VacancyModel, SalaryFrequency, RemoteType
+
+
+class VacancyLocation(BaseModel):
+    zip_code: str | None = None
+    city: str | None = None
+    address: str | None = None
+    state: str | None = None
+    country: str | None = None
+
+
+class Salary(BaseModel):
+    min: float | None = None
+    max: float | None = None
+    currency: str = "EUR"
+    frequency: SalaryFrequency = "month"
+
+
+class Hours(BaseModel):
+    min: int = 0
+    max: int = 40
+    fte: float = 1.0
+
+
+class ContactDetails(BaseModel):
+    email: str | None = None
+    first_name: str | None = None
+    last_name: str | None = None
+    phone_number: str | None = None
+    role: str | None = None
+
+
+class VacancyData(BaseModel):
+
+    # Required fields
+    reference_number: str
+    requisition_id: str
+    title: str
+    description: str
+    job_site_url: str
+    company_name: str
+    publish_date: datetime | None = None
+    category: List[str] = field(default_factory=list)
+    experience: List[str] = field(default_factory=list)
+    education: List[str] = field(default_factory=list)
+
+    # Connected data
+    hours: Hours = field(default_factory=Hours)
+    location: VacancyLocation = field(default_factory=VacancyLocation)
+    salary: Salary = field(default_factory=Salary)
+    recruiter: ContactDetails = field(default_factory=ContactDetails)
+
+    # Optional fields
+    status: str | None = None
+    parent_company_name: str | None = None
+    remote_type: RemoteType | None = None
+    expiration_date: datetime | None = None
+    last_updated_date: datetime | None = None
+
+    def to_model(self, feed: Feed):
+        return VacancyModel(
+            feed_id=feed.id,
+            organization=feed.organization,
+            reference_number=self.reference_number,
+            requisition_id=self.requisition_id,
+            title=self.title,
+            description=self.description,
+            status=self.status,
+            job_site_url=self.job_site_url,
+            company_name=self.company_name,
+            parent_company_name=self.parent_company_name,
+            remote_type=self.remote_type.value if self.remote_type else None,
+            publish_date=self.publish_date,
+            expiration_date=self.expiration_date,
+            last_updated_date=self.last_updated_date,
+            category=self.category,
+            experience=self.experience,
+            education=self.education,
+            hours_fte=self.hours.fte,
+            hours_min=self.hours.min,
+            hours_max=self.hours.max,
+            location_address=self.location.address,
+            location_zipcode=self.location.zip_code,
+            location_city=self.location.city,
+            location_state=self.location.state,
+            location_country=self.location.country,
+            salary_min=self.salary.min,
+            salary_max=self.salary.max,
+            salary_currency=self.salary.currency,
+            salary_frequency=self.salary.frequency.value if self.salary.frequency else SalaryFrequency.MONTH,
+            recruiter_first_name=self.recruiter.first_name,
+            recruiter_last_name=self.recruiter.last_name,
+            recruiter_phone_number=self.recruiter.phone_number,
+            recruiter_email=self.recruiter.email,
+            recruiter_role=self.recruiter.role,
+        )
+
+class Vacancy(VacancyData):
+    id: UUID
+    created_at: datetime
+    updated_at: Optional[datetime]
+    organization: UUID
+
+    @classmethod
+    def from_model(cls: "Vacancy", model: VacancyModel) -> "Vacancy":
+        hours = Hours(
+            min=model.hours_min,
+            max=model.hours_max,
+            fte=model.hours_fte,
+        )
+
+        location = VacancyLocation(
+            address=getattr(model, "location_address", None),
+            zip_code=getattr(model, "location_zipcode", None),
+            city=getattr(model, "location_city", None),
+            state=getattr(model, "location_state", None),
+            country=getattr(model, "location_country", None),
+        )
+
+        salary = Salary(
+            min=getattr(model, "salary_min", None),
+            max=getattr(model, "salary_max", None),
+            currency=getattr(model, "salary_currency", "EUR") or "EUR",
+            frequency=to_enum(SalaryFrequency, getattr(model, "salary_frequency", SalaryFrequency.MONTH) or SalaryFrequency.MONTH),
+        )
+
+        recruiter = ContactDetails(
+            first_name=getattr(model, "recruiter_first_name", None),
+            last_name=getattr(model, "recruiter_last_name", None),
+            phone_number=getattr(model, "recruiter_phone_number", None),
+            email=getattr(model, "recruiter_email", None),
+            role=getattr(model, "recruiter_role", None),
+        )
+
+        remote_type = to_enum(RemoteType, getattr(model, "remote_type", None))
+
+        return cls(
+            organization=getattr(model, "organization", None),
+            id=model.id,
+            created_at=model.created_at,
+            updated_at=model.updated_at,
+
+            reference_number=model.reference_number,
+            requisition_id=model.requisition_id,
+            title=model.title,
+            description=model.description,
+            job_site_url=model.job_site_url,
+            company_name=model.company_name,
+            publish_date=model.publish_date,
+            category=list(model.category or []),
+            experience=list(model.experience or []),
+            education=list(model.education or []),
+
+            hours=hours,
+            location=location,
+            salary=salary,
+            recruiter=recruiter,
+
+            status=getattr(model, "status", None),
+            parent_company_name=getattr(model, "parent_company_name", None),
+            remote_type=remote_type,
+            expiration_date=getattr(model, "expiration_date", None),
+            last_updated_date=getattr(model, "last_updated_date", None),
+        )

talentro_commons-0.1.1/src/talentro/vacancies/models.py

@@ -0,0 +1,81 @@
+from enum import StrEnum
+from uuid import UUID
+
+from datetime import datetime
+from typing import Optional, List
+
+from sqlalchemy import Column, JSON, UniqueConstraint, Enum
+from sqlmodel import Field
+
+from ..general.models import VacanciesOrganizationModel
+
+
+class SalaryFrequency(StrEnum):
+    MONTH = "month"
+    YEAR = "year"
+    WEEK = "week"
+    HOUR = "hour"
+
+class RemoteType(StrEnum):
+    ONSITE = "onsite"
+    HYBRID = "hybrid"
+    REMOTE = "remote"
+
+
+class Feed(VacanciesOrganizationModel, table=True):
+    name: str = Field(index=True)
+    status: str = Field(index=True)
+    file_url: Optional[str] = Field()
+    ats_link_id: Optional[UUID] = Field()
+    last_sync_date: Optional[datetime] = Field()
+    synced_vacancy_count: int = Field(default=0)
+    mapping: dict = Field(sa_column=Column(JSON))
+    custom_fields: dict = Field(sa_column=Column(JSON))
+
+
+class Vacancy(VacanciesOrganizationModel, table=True):
+    feed_id: UUID = Field(foreign_key="feed.id")
+    reference_number: str = Field(index=True)
+    requisition_id: str = Field(index=True)
+    title: str = Field(index=True)
+    description: str = Field()
+    status: str = Field()
+    job_site_url: str = Field()
+    company_name: str = Field(index=True)
+    parent_company_name: Optional[str] = Field()
+    remote_type: Optional[RemoteType] = Field(sa_column=Column(Enum(RemoteType)))
+    publish_date: Optional[datetime] = Field()
+    expiration_date: Optional[datetime] = Field()
+    last_updated_date: Optional[datetime] = Field()
+    category: List[str] = Field(sa_column=Column(JSON))
+    experience: List[str] = Field(sa_column=Column(JSON))
+    education: List[str] = Field(sa_column=Column(JSON))
+    hours_fte: Optional[float] = Field(default=1.0)
+    hours_min: Optional[int] = Field(default=1)
+    hours_max: Optional[int] = Field(default=40)
+    location_address: Optional[str] = Field()
+    location_zipcode: Optional[str] = Field()
+    location_city: Optional[str] = Field()
+    location_state: Optional[str] = Field()
+    location_country: Optional[str] = Field()
+    salary_min: Optional[float] = Field()
+    salary_max: Optional[float] = Field()
+    salary_currency: str = Field(default="EUR")
+    salary_frequency: SalaryFrequency = Field(sa_column=Column(Enum(SalaryFrequency)))
+    recruiter_first_name: Optional[str] = Field()
+    recruiter_last_name: Optional[str] = Field()
+    recruiter_phone_number: Optional[str] = Field()
+    recruiter_email: Optional[str] = Field()
+    recruiter_role: Optional[str] = Field()
+
+    __table_args__ = (
+        UniqueConstraint("feed_id", "reference_number", name="uq_feed_reference"),
+    )
+
+
+class Modification(VacanciesOrganizationModel, table=True):
+    name: str = Field(index=True)
+    type: str = Field(index=True)
+    selector_configuration: dict = Field(sa_column=Column(JSON))
+    changes_configuration: dict = Field(sa_column=Column(JSON))
+