sendgo-go

package main

import (
    "fmt"
    "log"
    "os"

    sendgo "github.com/send-go/go/sendgo"
)

func main() {
    client, err := sendgo.New(sendgo.Config{
        AccessKey:      os.Getenv("SENDGO_ACCESS_KEY"),
        SecretKey:      os.Getenv("SENDGO_SECRET_KEY"),
        KakaoSenderKey: os.Getenv("SENDGO_KAKAO_SENDER_KEY"),
        SmsSenderKey:   os.Getenv("SENDGO_SMS_SENDER_KEY"),
        ApiVersion:     "v2",
    })
    if err != nil {
        log.Fatal(err)
    }

    // 알림톡 발송
    result, err := client.Alimtalk.Send(sendgo.AlimtalkRequest{
        TemplateCode: "ORDER_CONFIRM_001",
        Contacts: []sendgo.Contact{
            {Contact: "01012345678", Name: "홍길동", Var1: "ORD-001", Var2: "29,000원"},
        },
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("발송 결과: %v\n", result)
}

package main

import (
    "log"
    "os"
    sendgo "github.com/send-go/go/sendgo"
)

func main() {
    client, _ := sendgo.New(sendgo.Config{
        AccessKey:      os.Getenv("SENDGO_ACCESS_KEY"),
        SecretKey:      os.Getenv("SENDGO_SECRET_KEY"),
        KakaoSenderKey: os.Getenv("SENDGO_KAKAO_SENDER_KEY"),
        SmsSenderKey:   os.Getenv("SENDGO_SMS_SENDER_KEY"),
        ApiVersion:     "v2",
    })

    // 다건 발송
    client.Alimtalk.Send(sendgo.AlimtalkRequest{
        TemplateCode: "ORDER_CONFIRM_001",
        Contacts: []sendgo.Contact{
            {Contact: "01011111111", Name: "홍길동", Var1: "ORD-001", Var2: "29,000원"},
            {Contact: "01022222222", Name: "김철수", Var1: "ORD-002", Var2: "15,000원"},
            {Contact: "01033333333", Name: "이영희", Var1: "ORD-003", Var2: "52,000원"},
        },
    })

    // 예약 발송
    client.Alimtalk.Send(sendgo.AlimtalkRequest{
        TemplateCode: "PROMO_SUMMER_2026",
        ScheduleType: "SCHEDULED",
        At:           sendgo.String("2026-07-28 09:00:00"),
        Contacts: []sendgo.Contact{
            {Contact: "01012345678", Var1: "여름 한정 50% 할인"},
        },
    })

    // SMS 자동 대체 발송
    client.Alimtalk.Send(sendgo.AlimtalkRequest{
        TemplateCode: "DELIVERY_START_001",
        ReplaceSms:   "Y",
        SmsSubject:   sendgo.String("[배송 시작 안내]"),
        SmsContent:   sendgo.String("주문하신 상품이 출고되었습니다.\n송장번호: #{var2}"),
        Contacts: []sendgo.Contact{
            {Contact: "01012345678", Var1: "ORD-001", Var2: "1234567890"},
        },
    })
}

// 텍스트형
client.Friendtalk.Send(sendgo.FriendtalkRequest{
    Content: "안녕하세요! 7월 한정 특가 이벤트를 확인해보세요.",
    Contacts: []sendgo.Contact{
        {Contact: "01012345678"},
    },
})

// 이미지형
client.Friendtalk.Send(sendgo.FriendtalkRequest{
    MessageType: "FI",
    Content:     "이번 주 특가 상품을 확인하세요!",
    ImageURL:    "https://cdn.example.com/banner.jpg",
    ImageLink:   "https://example.com/event",
    Contacts: []sendgo.Contact{
        {Contact: "01012345678"},
    },
})

// 단건 발송 — 채널 친구 대상
_, err := client.BrandMessage.Send(sendgo.BrandMessageRequest{
    Targeting:          "M",
    MessageType:        "FL",
    FriendTemplateUUID: "9cd5460b-6458-4edc-9b11-c26d3013c340",
    Contacts: []sendgo.Contact{
        {Contact: "01012345678", Var1: "29,000원"},
    },
})

// 동보 발송 — 수신 동의한 전체 채널 친구 (Contacts 불필요)
_, err = client.BrandMessage.Broadcast(sendgo.BrandMessageRequest{
    MessageType:        "FW",
    FriendTemplateUUID: "9cd5460b-6458-4edc-9b11-c26d3013c340",
})

// 캠페인 조회
list, err := client.BrandMessage.Campaigns(sendgo.BrandMessageListQuery{Count: 10})
one, err := client.BrandMessage.Campaign("1f0a6d0e-6b3b-4f0f-9b2f-2f6f6a1b7c11")

// SMS
client.SMS.SendSMS(sendgo.SmsRequest{
    Content: "[Sendgo] 인증번호: 123456 (5분 이내 입력)",
    Contacts: []sendgo.Contact{
        {Contact: "01012345678"},
    },
})

// LMS
client.SMS.SendLMS(sendgo.SmsRequest{
    Subject: sendgo.String("[중요] 서비스 점검 안내"),
    Content: "안녕하세요. 서비스 점검이 예정되어 있습니다.\n■ 일시: 2026-07-25 02:00 ~ 06:00",
    Contacts: []sendgo.Contact{
        {Contact: "01012345678"},
    },
})

// MMS
client.SMS.SendMMS(sendgo.SmsRequest{
    Subject: sendgo.String("[이벤트] 7월 특가"),
    Content: "이번 달 특가 상품을 확인하세요!",
    Contacts: []sendgo.Contact{
        {Contact: "01011111111"},
        {Contact: "01022222222"},
    },
})

// 예약 문자
client.SMS.SendSMS(sendgo.SmsRequest{
    Content:      "[알림] 예약 미팅을 확인해주세요.",
    ScheduleType: "SCHEDULED",
    At:           sendgo.String("2026-07-23 08:00:00"),
    Contacts: []sendgo.Contact{{Contact: "01012345678"}},
})

package main

import (
    "encoding/json"
    "net/http"
    "os"
    sendgo "github.com/send-go/go/sendgo"
)

var sg *sendgo.Client

func init() {
    var err error
    sg, err = sendgo.New(sendgo.Config{
        AccessKey:      os.Getenv("SENDGO_ACCESS_KEY"),
        SecretKey:      os.Getenv("SENDGO_SECRET_KEY"),
        KakaoSenderKey: os.Getenv("SENDGO_KAKAO_SENDER_KEY"),
        ApiVersion:     "v2",
    })
    if err != nil {
        panic(err)
    }
}

func notifyOrderHandler(w http.ResponseWriter, r *http.Request) {
    var req struct {
        Phone   string `json:"phone"`
        OrderNo string `json:"order_no"`
    }
    json.NewDecoder(r.Body).Decode(&req)

    _, err := sg.Alimtalk.Send(sendgo.AlimtalkRequest{
        TemplateCode: "ORDER_CONFIRM_001",
        Contacts:     []sendgo.Contact{{Contact: req.Phone, Var1: req.OrderNo}},
    })
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    json.NewEncoder(w).Encode(map[string]bool{"success": true})
}

func main() {
    http.HandleFunc("/api/notify/order", notifyOrderHandler)
    http.ListenAndServe(":8080", nil)
}

package main

import (
    "net/http"
    "os"

    "github.com/gin-gonic/gin"
    sendgo "github.com/send-go/go/sendgo"
)

func main() {
    sg, _ := sendgo.New(sendgo.Config{
        AccessKey:      os.Getenv("SENDGO_ACCESS_KEY"),
        SecretKey:      os.Getenv("SENDGO_SECRET_KEY"),
        KakaoSenderKey: os.Getenv("SENDGO_KAKAO_SENDER_KEY"),
        ApiVersion:     "v2",
    })

    r := gin.Default()

    r.POST("/api/notify/order", func(c *gin.Context) {
        var req struct {
            Phone   string `json:"phone"`
            OrderNo string `json:"order_no"`
        }
        c.ShouldBindJSON(&req)

        _, err := sg.Alimtalk.Send(sendgo.AlimtalkRequest{
            TemplateCode: "ORDER_CONFIRM_001",
            Contacts:     []sendgo.Contact{{Contact: req.Phone, Var1: req.OrderNo}},
        })
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }
        c.JSON(http.StatusOK, gin.H{"success": true})
    })

    r.Run(":8080")
}

import "github.com/send-go/go/sendgo"

_, err := client.Alimtalk.Send(req)
if err != nil {
    var se *sendgo.SendgoError
    if errors.As(err, &se) {
        fmt.Printf("발송 실패: HTTP %d [%s]\n", se.StatusCode, se.ErrorCode)
        switch se.ErrorCode {
        case "INVALID_ACCESS_KEY", "INVALID_SECRET_KEY":
            alertOps("Sendgo 인증키를 확인하세요.")
        case "INVALID_TEMPLATE_CODE":
            log.Printf("존재하지 않는 템플릿: %s", se.Message)
        case "PAYMENT_REQUIRED":
            alertOps("Sendgo 크레딧이 부족합니다.")
        }
    }
}

err := client.SMS.SendLMS(sendgo.SmsRequest{
    Subject:  sendgo.String("[중요] 서비스 점검 안내"),
    Content:  "...",
    Contacts: []sendgo.Contact{{Contact: "01012345678"}},
})

// 짧은 URL 생성 (v2 전용)
created, err := client.ShortURL.Create(sendgo.ShortURLRequest{
	TargetURL: "https://example.com/promotions/summer-sale",
	Title:     "여름 세일 랜딩",
})
if err != nil {
	log.Fatal(err)
}

code := created["data"].(map[string]any)["code"].(string)

// 반응 통계 — 일별 추이 + 디바이스/유입경로/국가별 분해
stats, err := client.ShortURL.Stats(code, sendgo.ShortURLStatsQuery{From: "2026-08-01"})

client.ShortURL.List(sendgo.ShortURLListQuery{Count: 10})
client.ShortURL.Show(code)
client.ShortURL.Deactivate(code) // 리다이렉트만 중지, 통계는 남는다

// 1단계 — 카카오가 관리자 휴대폰으로 인증번호를 SMS 발송한다 (응답에 번호는 없다)
if _, err := client.KakaoSenders.RequestToken("@my-channel", "01012345678"); err != nil {
    log.Fatal(err)
}

// 2단계 — 사람이 받은 인증번호로 발신프로필 생성
created, err := client.KakaoSenders.Create(sendgo.KakaoSenderCreateRequest{
    Token:        "123456",
    YellowID:     "@my-channel",
    PhoneNumber:  "01012345678",
    CategoryCode: "001001", // Categories("") 로 조회
})
if err != nil {
    log.Fatal(err)
}

sender := created["data"].(map[string]any)["sender"].(map[string]any)
kakaoSenderKey := sender["kakaoSenderKey"].(string)

client.KakaoSenders.Categories("")
client.KakaoSenders.List()
client.KakaoSenders.Sync("")               // 전체 상태 동기화 (하루 한 번 권장)
client.KakaoSenders.Sync(kakaoSenderKey)   // 단건

created, err := client.NoticeTemplates.Create(sendgo.NoticeTemplateRequest{
    KakaoSenderKey:        kakaoSenderKey,
    TemplateName:          "주문 접수 안내",
    TemplateContent:       "#{name}님, 주문 #{orderNo}이 접수되었습니다.",
    TemplateMessageType:   "BA",   // BA 기본형 / EX 부가정보형 / AD 채널추가형 / MI 복합형
    TemplateEmphasizeType: "NONE", // NONE / TEXT / ITEM_LIST / IMAGE
    CategoryCode:          "001001",

    // sendgo 자체 정책 게이트 — 카카오 심사와 별개다
    MessagePurpose:       "order_delivery",
    LegalBasis:           "transaction",
    BenefitOrigin:        "none",
    ExpiryType:           "none",
    OptInReviewConfirmed: true,
    CtaClearConfirmed:    true,
    PolicyConfirmed:      true,
})

template := created["data"].(map[string]any)["template"].(map[string]any)
templateCode := template["templateCode"].(string)

// 검수 요청 — 증빙이 필요하면 파일도 붙인다 (첨부가 있으면 comment 필수)
client.NoticeTemplates.RequestInspection(templateCode, "", nil)

// 결과는 비동기다. 웹훅이 없으므로 폴링한다
synced, _ := client.NoticeTemplates.Sync(templateCode)
status := synced["data"].(map[string]any)["template"].(map[string]any)["inspectionStatus"]
// REG → REQ → APR / REJ

client.NoticeTemplates.List(sendgo.NoticeTemplateListQuery{
    KakaoSenderKey:   kakaoSenderKey,
    InspectionStatus: "APR",
})
client.NoticeTemplates.Show(templateCode)
client.NoticeTemplates.Update(templateCode, req)   // 본문이 바뀌면 재검수 필요
client.NoticeTemplates.CancelInspection(templateCode)
client.NoticeTemplates.CancelApproval(templateCode)
client.NoticeTemplates.Release(templateCode)       // 휴면 해제
client.NoticeTemplates.Delete(templateCode)        // sendgo 목록에서만 삭제된다
client.NoticeTemplates.Categories("")

f, _ := os.Open("banner.jpg")
defer f.Close()

client.NoticeTemplates.CreateWithImage(req, sendgo.MultipartFile{
    FileName: "banner.jpg",
    Content:  f,
})

created, err := client.BrandTemplates.Create(sendgo.BrandTemplateRequest{
    KakaoSenderKey:  kakaoSenderKey,
    TemplateName:    "여름 세일 안내",
    TemplateType:    "FI", // FT/FI/FW/FL/FC/FM/FP/FA — 서버가 chatBubbleType 으로 변환
    TemplateContent: "여름 세일이 시작되었습니다.",
    ImageURL:        "https://mud-kage.kakao.com/....jpg",
})

// 동보 발송(targeting="F")에는 변수가 없는 템플릿만 쓸 수 있다
// created["data"]["template"]["containsVariables"]

client.BrandTemplates.List(sendgo.BrandTemplateListQuery{KakaoSenderKey: kakaoSenderKey})
client.BrandTemplates.Sync(templateCode)
client.BrandTemplates.Import(kakaoSenderKey)   // 카카오에 있는 템플릿 가져오기
client.BrandTemplates.Delete(templateCode)     // 카카오에서도 삭제된다

// 계정 종류에 맞는 유형과 유형별 필수 서류
client.SenderRegistration.NumberTypes()

// 형식·중복 미리 확인
check, _ := client.SenderRegistration.Validate("02-1234-5678", "team_main")

csu, _ := os.Open("csu.pdf")
defer csu.Close()

created, err := client.SenderRegistration.Create(
    sendgo.SenderRegistrationRequest{
        SenderAlias:      "고객센터 대표번호",
        SenderNumberType: "team_main", // personal_other / team_main / team_other_company
        PhoneE164:        "02-1234-5678",
        // check 의 duplicationReasonRequired 가 true 면 필수
        // DuplicationReason: "부서별 분리 운영",
    },
    []sendgo.MultipartFile{
        {FieldName: "csuCertificate", FileName: "csu.pdf", Content: csu},
    },
)

// created["data"]["sender"]["status"] == "PENDING" — 운영자 승인 후 SUCCESS

client.SenderRegistration.List()
client.SenderRegistration.Update(senderKey, "새 이름", "")
client.SenderRegistration.Delete(senderKey)

client.MessageTemplates.Create(sendgo.MessageTemplateRequest{
    MessageTranType:    "LMS",
    MessageTranSubject: "주문 안내", // LMS·MMS 는 필수
    MessageTranMsg:     "주문이 접수되었습니다.",
})

client.MessageTemplates.List(sendgo.MessageTemplateListQuery{MessageType: "LMS"})
client.MessageTemplates.Update(templateKey, req)
client.MessageTemplates.Delete(templateKey)

created, _ := client.Webhook.Subscribe(sendgo.WebhookSubscriptionRequest{
    URL:     "https://reseller.example.com/hooks/sendgo",
    Enabled: true,
})

// 시크릿은 이 응답에서 한 번만 나온다. 즉시 저장한다.
secret := created["data"].(map[string]any)["secret"]

client.Webhook.Show()          // 구독 설정 + 마지막 전송 결과
client.Webhook.Test()          // 배선 확인
client.Webhook.Unsubscribe()

func handleWebhook(w http.ResponseWriter, r *http.Request) {
    body, _ := io.ReadAll(r.Body)

    if !sendgo.VerifyWebhookSignature(body, r.Header.Get("X-Sendgo-Signature"), secret) {
        http.Error(w, "invalid signature", http.StatusUnauthorized)
        return
    }

    var payload struct {
        Event      string         `json:"event"`
        DeliveryID string         `json:"deliveryId"`
        Data       map[string]any `json:"data"`
    }
    _ = json.Unmarshal(body, &payload)

    // 처리는 큐로. 여기서 오래 끌면 재시도가 쌓인다.
    w.WriteHeader(http.StatusNoContent)
}

f, _ := os.Open("banner.jpg")
defer f.Close()

uploaded, _ := client.KakaoImages.Upload("default", sendgo.MultipartFile{
    FileName: "banner.jpg",
    Content:  f,
})

imageURL := uploaded["data"].(map[string]any)["imageUrl"].(string)

client.KakaoImages.UploadMany("carousel_feed", slides)
client.KakaoImages.Types()   // 유형별 필드·최대 개수

// 증분만 가져간다. 하루 한 번이면 충분하다.
client.RejectedNumbers.List(sendgo.RejectedNumberListQuery{Since: "2026-09-01", Count: 500})

account, err := sendgo.NewAccount(os.Getenv("SENDGO_AGENT_TOKEN"), "")
if err != nil { log.Fatal(err) }
result, err := account.Me()
if err != nil { log.Fatal(err) }
_ = result

folders, err := client.TemplateFolders.List(sendgo.TemplateFolderListQuery{TemplateType: "notice"})
if err != nil { return err }
_ = folders
_, err = client.TemplateFolders.Create(sendgo.TemplateFolderCreateRequest{Name: "주문 안내"})
if err != nil { return err }
_, err = client.TemplateFolders.Assign(sendgo.TemplateFolderAssignRequest{
    TemplateType: "notice", KakaoSenderKey: kakaoSenderKey,
    TemplateCodes: []string{"ORDER_001"}, FolderUUID: nil,
})
if err != nil { return err }
_, err = client.NoticeTemplates.List(sendgo.NoticeTemplateListQuery{FolderUUID: "none"})
// 템플릿 생성 요청의 FolderUUID 필드로 폴더를 지정합니다.