Contacts & Templates

// services/sent.service.ts
async listContacts(): Promise<ContactItem[]> {
  const response = await this.client.contacts.list({ page: 1, page_size: 100 });
  const contacts = response.data?.contacts ?? [];
  return contacts.map((c) => ({
    id: c.id,
    phoneNumber: c.phone_number, // ← snake → camel
    createdAt: c.created_at,
  }));
}

async createContact(phoneNumber: string, sandbox?: boolean): Promise<ContactItem> {
  const response = await this.client.contacts.create({
    phone_number: phoneNumber,
    sandbox: sandbox ?? false,
  });
  const c = response.data ?? {};
  return { id: c.id, phoneNumber: c.phone_number, createdAt: c.created_at };
}

async deleteContact(id: string): Promise<void> {
  await this.client.contacts.delete(id, {});
}

# app/services/sent_service.py
async def list_contacts(self) -> CanonicalContactList:
    response = await self._client.contacts.list(page=1, page_size=100)
    contacts = response.data.contacts if response.data and response.data.contacts else []
    return CanonicalContactList(
        items=[
            CanonicalContact(id=c.id, phoneNumber=c.phone_number, createdAt=c.created_at)
            for c in contacts
        ]
    )

async def create_contact(self, request: CanonicalCreateContactRequest) -> CanonicalContact:
    response = await self._client.contacts.create(
        phone_number=request.phoneNumber,
        sandbox=request.sandbox,
    )
    c = response.data
    return CanonicalContact(
        id=getattr(c, "id", None),
        phoneNumber=getattr(c, "phone_number", None),
        createdAt=getattr(c, "created_at", None),
    )

async def delete_contact(self, contact_id: str) -> None:
    await self._client.contacts.delete(contact_id)

// internal/services/sentclient.go
func (c *SentClient) CreateContact(ctx context.Context, phoneNumber string, sandbox bool) (*sentdm.APIResponseOfContact, error) {
    ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
    defer cancel()

    params := sentdm.ContactNewParams{PhoneNumber: phoneNumber}
    if sandbox {
        params.Sandbox = sentdm.Bool(true)
    }
    return c.client.Contacts.New(ctx, params)
}

// internal/models/contract.go — map SDK contact → contract shape.
func NewContactResponse(c sentdm.ContactResponse) ContactResponse {
    return ContactResponse{
        ID:          c.ID,
        PhoneNumber: c.PhoneNumber, // ← snake → camel at the JSON tag
        CreatedAt:   c.CreatedAt,
    }
}

// services/sent.service.ts
async listTemplates(): Promise<TemplateItem[]> {
  const response = await this.client.templates.list({ page: 1, page_size: 100 });
  const templates = response.data?.templates ?? [];
  return templates.map((t) => ({
    id: t.id,
    name: t.name,
    channel: t.channels?.[0],  // ← channels[] → channel
    status: t.status,
    body: undefined,           // ← SDK has no rendered body
    category: t.category,
    language: t.language,
  }));
}

async getTemplate(id: string): Promise<TemplateItem> {
  const response = await this.client.templates.retrieve(id);
  const t = response.data ?? {};
  return {
    id: t.id, name: t.name, channel: t.channels?.[0], status: t.status,
    body: undefined, category: t.category, language: t.language,
  };
}

# app/services/sent_service.py
def _channel_from_template(tmpl) -> str | None:
    channels = getattr(tmpl, "channels", None)
    return channels[0] if channels else None

async def list_templates(self) -> CanonicalTemplateList:
    response = await self._client.templates.list(page=1, page_size=100)
    templates = response.data.templates if response.data and response.data.templates else []
    return CanonicalTemplateList(
        items=[
            CanonicalTemplate(
                id=t.id, name=t.name,
                channel=_channel_from_template(t),  # ← channels[] → channel
                status=t.status,
                body=getattr(t, "body", None),      # ← usually None
                category=t.category, language=t.language,
            )
            for t in templates
        ]
    )

async def get_template(self, template_id: str) -> CanonicalTemplate:
    response = await self._client.templates.retrieve(template_id)
    t = response.data
    return CanonicalTemplate(
        id=getattr(t, "id", None), name=getattr(t, "name", None),
        channel=_channel_from_template(t), status=getattr(t, "status", None),
        body=getattr(t, "body", None),
        category=getattr(t, "category", None), language=getattr(t, "language", None),
    )

// internal/models/contract.go — map SDK template → contract shape.
func NewTemplateResponse(t sentdm.Template) TemplateResponse {
    channel := ""
    if len(t.Channels) > 0 {
        channel = t.Channels[0] // ← channels[] → channel
    }
    return TemplateResponse{
        ID:       t.ID,
        Name:     t.Name,
        Channel:  channel,
        Status:   t.Status,
        Body:     "", // ← SDK carries no rendered body
        Category: t.Category,
        Language: t.Language,
    }
}