GOWA - WhatsApp REST API with support for UI, Multi Account, Webhooks, and MCP, and Chatwoot. Built with Golang for efficient memory use.
Go botgogolanggolang-whatsappgolang-whatsapp-apirestrest-apiwhatsappwhatsapp-apiwhatsapp-api-gowhatsapp-multi-devicewhatsapp-web-multi-device
package usecase
import (
"context"
"fmt"
"github.com/sirupsen/logrus"
"go.mau.fi/whatsmeow"
"go.mau.fi/whatsmeow/types"
"github.com/aldinokemal/go-whatsapp-web-multidevice/config"
domainGroup "github.com/aldinokemal/go-whatsapp-web-multidevice/domains/group"
"github.com/aldinokemal/go-whatsapp-web-multidevice/infrastructure/whatsapp"
pkgError "github.com/aldinokemal/go-whatsapp-web-multidevice/pkg/error"
"github.com/aldinokemal/go-whatsapp-web-multidevice/pkg/utils"
"github.com/aldinokemal/go-whatsapp-web-multidevice/validations"
)
type serviceGroup struct{}
func NewGroupService() domainGroup.IGroupUsecase {
return &serviceGroup{}
}
func (service serviceGroup) JoinGroupWithLink(ctx context.Context, request domainGroup.JoinGroupWithLinkRequest) (groupID string, err error) {
if err = validations.ValidateJoinGroupWithLink(ctx, request); err != nil {
return groupID, err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return groupID, pkgError.ErrWaCLI
}
utils.MustLogin(client)
jid, err := client.JoinGroupWithLink(ctx, request.Link)
if err != nil {
return
}
return jid.String(), nil
}
func (service serviceGroup) LeaveGroup(ctx context.Context, request domainGroup.LeaveGroupRequest) (err error) {
if err = validations.ValidateLeaveGroup(ctx, request); err != nil {
return err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return pkgError.ErrWaCLI
}
JID, err := utils.ValidateJidWithLogin(client, request.GroupID)
if err != nil {
return err
}
return client.LeaveGroup(ctx, JID)
}
func (service serviceGroup) CreateGroup(ctx context.Context, request domainGroup.CreateGroupRequest) (groupID string, err error) {
if err = validations.ValidateCreateGroup(ctx, request); err != nil {
return groupID, err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return groupID, pkgError.ErrWaCLI
}
utils.MustLogin(client)
participantsJID, err := service.participantToJID(ctx, request.Participants)
if err != nil {
return
}
groupConfig := whatsmeow.ReqCreateGroup{
Name: request.Title,
Participants: participantsJID,
GroupParent: types.GroupParent{},
GroupLinkedParent: types.GroupLinkedParent{},
}
groupInfo, err := client.CreateGroup(ctx, groupConfig)
if err != nil {
return
}
return groupInfo.JID.String(), nil
}
func (service serviceGroup) GetGroupInfoFromLink(ctx context.Context, request domainGroup.GetGroupInfoFromLinkRequest) (response domainGroup.GetGroupInfoFromLinkResponse, err error) {
if err = validations.ValidateGetGroupInfoFromLink(ctx, request); err != nil {
return response, err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return response, pkgError.ErrWaCLI
}
utils.MustLogin(client)
groupInfo, err := client.GetGroupInfoFromLink(ctx, request.Link)
if err != nil {
return response, err
}
response = domainGroup.GetGroupInfoFromLinkResponse{
GroupID: groupInfo.JID.String(),
Name: groupInfo.Name,
Topic: groupInfo.Topic,
CreatedAt: groupInfo.GroupCreated,
ParticipantCount: len(groupInfo.Participants),
IsLocked: groupInfo.IsLocked,
IsAnnounce: groupInfo.IsAnnounce,
IsEphemeral: groupInfo.IsEphemeral,
Description: groupInfo.Topic, // Topic serves as description
}
return response, nil
}
func (service serviceGroup) ManageParticipant(ctx context.Context, request domainGroup.ParticipantRequest) (result []domainGroup.ParticipantStatus, err error) {
if err = validations.ValidateParticipant(ctx, request); err != nil {
return result, err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return result, pkgError.ErrWaCLI
}
utils.MustLogin(client)
groupJID, err := utils.ValidateJidWithLogin(client, request.GroupID)
if err != nil {
return result, err
}
participantsJID, err := service.participantToJID(ctx, request.Participants)
if err != nil {
return result, err
}
participants, err := client.UpdateGroupParticipants(ctx, groupJID, participantsJID, request.Action)
if err != nil {
return result, err
}
for _, participant := range participants {
if participant.Error == 403 && participant.AddRequest != nil {
result = append(result, domainGroup.ParticipantStatus{
Participant: participant.JID.String(),
Status: "error",
Message: "Failed to add participant",
})
} else {
result = append(result, domainGroup.ParticipantStatus{
Participant: participant.JID.String(),
Status: "success",
Message: "Action success",
})
}
}
return result, nil
}
func (service serviceGroup) GetGroupParticipants(ctx context.Context, request domainGroup.GetGroupParticipantsRequest) (response domainGroup.GetGroupParticipantsResponse, err error) {
if err = validations.ValidateGetGroupParticipants(ctx, request); err != nil {
return response, err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return response, pkgError.ErrWaCLI
}
groupJID, err := utils.ValidateJidWithLogin(client, request.GroupID)
if err != nil {
return response, err
}
groupInfo, err := client.GetGroupInfo(ctx, groupJID)
if err != nil {
return response, err
}
response.GroupID = groupJID.String()
if groupInfo != nil {
response.Name = groupInfo.GroupName.Name
response.Participants = make([]domainGroup.GroupParticipant, 0, len(groupInfo.Participants))
userInfo := userInfoMapForJIDs(ctx, client, jidsForGetUserInfoGroup(ctx, client, groupInfo.Participants))
for _, participant := range groupInfo.Participants {
lookupJID := groupParticipantPhoneJID(ctx, client, participant)
displayName := resolveParticipantDisplayName(ctx, client, participant.DisplayName, lookupJID, participant.JID, userInfo)
participantData := domainGroup.GroupParticipant{
JID: participant.JID.String(),
PhoneNumber: groupParticipantPhoneUser(ctx, client, participant),
LID: participant.LID.String(),
DisplayName: displayName,
IsAdmin: participant.IsAdmin,
IsSuperAdmin: participant.IsSuperAdmin,
}
response.Participants = append(response.Participants, participantData)
}
}
return response, nil
}
func (service serviceGroup) GetGroupRequestParticipants(ctx context.Context, request domainGroup.GetGroupRequestParticipantsRequest) (result []domainGroup.GetGroupRequestParticipantsResponse, err error) {
if err = validations.ValidateGetGroupRequestParticipants(ctx, request); err != nil {
return result, err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return result, pkgError.ErrWaCLI
}
groupJID, err := utils.ValidateJidWithLogin(client, request.GroupID)
if err != nil {
return result, err
}
participants, err := client.GetGroupRequestParticipants(ctx, groupJID)
if err != nil {
return result, err
}
userInfo := userInfoMapForJIDs(ctx, client, jidsForGetUserInfoWireJIDs(ctx, client, participants))
for _, participant := range participants {
lookupJID, phoneDigits := wireParticipantLookupAndPhone(ctx, client, participant.JID)
displayName := resolveParticipantDisplayName(ctx, client, "", lookupJID, participant.JID, userInfo)
result = append(result, domainGroup.GetGroupRequestParticipantsResponse{
JID: participant.JID.String(),
PhoneNumber: phoneDigits,
DisplayName: displayName,
RequestedAt: participant.RequestedAt,
})
}
return result, nil
}
func (service serviceGroup) ManageGroupRequestParticipants(ctx context.Context, request domainGroup.GroupRequestParticipantsRequest) (result []domainGroup.ParticipantStatus, err error) {
if err = validations.ValidateManageGroupRequestParticipants(ctx, request); err != nil {
return result, err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return result, pkgError.ErrWaCLI
}
groupJID, err := utils.ValidateJidWithLogin(client, request.GroupID)
if err != nil {
return result, err
}
participantsJID, err := service.participantToJID(ctx, request.Participants)
if err != nil {
return result, err
}
participants, err := client.UpdateGroupRequestParticipants(ctx, groupJID, participantsJID, request.Action)
if err != nil {
return result, err
}
for _, participant := range participants {
if participant.Error != 0 {
result = append(result, domainGroup.ParticipantStatus{
Participant: participant.JID.String(),
Status: "error",
Message: fmt.Sprintf("Action %s failed (code %d)", request.Action, participant.Error),
})
} else {
result = append(result, domainGroup.ParticipantStatus{
Participant: participant.JID.String(),
Status: "success",
Message: fmt.Sprintf("Action %s success", request.Action),
})
}
}
return result, nil
}
func (service serviceGroup) participantToJID(ctx context.Context, participants []string) ([]types.JID, error) {
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return nil, pkgError.ErrWaCLI
}
var participantsJID []types.JID
for _, participant := range participants {
formattedParticipant := participant + config.WhatsappTypeUser
if !utils.IsOnWhatsapp(client, formattedParticipant) {
return nil, pkgError.ErrUserNotRegistered
}
if participantJID, err := types.ParseJID(formattedParticipant); err == nil {
participantsJID = append(participantsJID, participantJID)
}
}
return participantsJID, nil
}
func (service serviceGroup) SetGroupPhoto(ctx context.Context, request domainGroup.SetGroupPhotoRequest) (pictureID string, err error) {
if err = validations.ValidateSetGroupPhoto(ctx, request); err != nil {
return pictureID, err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return pictureID, pkgError.ErrWaCLI
}
groupJID, err := utils.ValidateJidWithLogin(client, request.GroupID)
if err != nil {
return pictureID, err
}
var photoBytes []byte
if request.Photo != nil {
// Process the image for WhatsApp group photo requirements
logrus.Printf("Processing group photo: %s (size: %d bytes)", request.Photo.Filename, request.Photo.Size)
processedImageBuffer, err := utils.ProcessGroupPhoto(request.Photo)
if err != nil {
logrus.Printf("Failed to process group photo: %v", err)
return pictureID, err
}
logrus.Printf("Successfully processed group photo: %d bytes -> %d bytes",
request.Photo.Size, processedImageBuffer.Len())
// Convert buffer to byte slice
photoBytes = processedImageBuffer.Bytes()
}
pictureID, err = client.SetGroupPhoto(ctx, groupJID, photoBytes)
if err != nil {
logrus.Printf("Failed to set group photo: %v", err)
return pictureID, err
}
return pictureID, nil
}
func (service serviceGroup) SetGroupName(ctx context.Context, request domainGroup.SetGroupNameRequest) (err error) {
if err = validations.ValidateSetGroupName(ctx, request); err != nil {
return err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return pkgError.ErrWaCLI
}
groupJID, err := utils.ValidateJidWithLogin(client, request.GroupID)
if err != nil {
return err
}
return client.SetGroupName(ctx, groupJID, request.Name)
}
func (service serviceGroup) SetGroupLocked(ctx context.Context, request domainGroup.SetGroupLockedRequest) (err error) {
if err = validations.ValidateSetGroupLocked(ctx, request); err != nil {
return err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return pkgError.ErrWaCLI
}
groupJID, err := utils.ValidateJidWithLogin(client, request.GroupID)
if err != nil {
return err
}
return client.SetGroupLocked(ctx, groupJID, request.Locked)
}
func (service serviceGroup) SetGroupAnnounce(ctx context.Context, request domainGroup.SetGroupAnnounceRequest) (err error) {
if err = validations.ValidateSetGroupAnnounce(ctx, request); err != nil {
return err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return pkgError.ErrWaCLI
}
groupJID, err := utils.ValidateJidWithLogin(client, request.GroupID)
if err != nil {
return err
}
return client.SetGroupAnnounce(ctx, groupJID, request.Announce)
}
func (service serviceGroup) SetGroupTopic(ctx context.Context, request domainGroup.SetGroupTopicRequest) (err error) {
if err = validations.ValidateSetGroupTopic(ctx, request); err != nil {
return err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return pkgError.ErrWaCLI
}
groupJID, err := utils.ValidateJidWithLogin(client, request.GroupID)
if err != nil {
return err
}
// SetGroupTopic with auto-generated IDs (previousID and newID will be handled automatically)
return client.SetGroupTopic(ctx, groupJID, "", "", request.Topic)
}
// GroupInfo retrieves detailed information about a WhatsApp group
func (service serviceGroup) GroupInfo(ctx context.Context, request domainGroup.GroupInfoRequest) (response domainGroup.GroupInfoResponse, err error) {
// Validate the incoming request
if err = validations.ValidateGroupInfo(ctx, request); err != nil {
return response, err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return response, pkgError.ErrWaCLI
}
// Ensure we are logged in
utils.MustLogin(client)
// Validate and parse the provided group JID / ID
groupJID, err := utils.ValidateJidWithLogin(client, request.GroupID)
if err != nil {
return response, err
}
// Fetch group information from WhatsApp
groupInfo, err := client.GetGroupInfo(ctx, groupJID)
if err != nil {
return response, err
}
// Map the response
if groupInfo != nil {
response.Data = *groupInfo
}
return response, nil
}
func (service serviceGroup) GetGroupInviteLink(ctx context.Context, request domainGroup.GetGroupInviteLinkRequest) (response domainGroup.GetGroupInviteLinkResponse, err error) {
if err = validations.ValidateGetGroupInviteLink(ctx, request); err != nil {
return response, err
}
client := whatsapp.ClientFromContext(ctx)
if client == nil {
return response, pkgError.ErrWaCLI
}
utils.MustLogin(client)
groupJID, err := utils.ValidateJidWithLogin(client, request.GroupID)
if err != nil {
return response, err
}
inviteLink, err := client.GetGroupInviteLink(ctx, groupJID, request.Reset)
if err != nil {
return response, err
}
response = domainGroup.GetGroupInviteLinkResponse{
InviteLink: inviteLink,
GroupID: request.GroupID,
}
return response, nil
}
// --- Group participant display / identity (LID vs phone JIDs; whatsmeow USync keys) ---
func userInfoMapForJIDs(ctx context.Context, client *whatsmeow.Client, jids []types.JID) map[types.JID]types.UserInfo {
if len(jids) == 0 {
return nil
}
m, _ := client.GetUserInfo(ctx, jids)
return m
}
func jidsForGetUserInfoGroup(ctx context.Context, client *whatsmeow.Client, participants []types.GroupParticipant) []types.JID {
uniq := make(map[types.JID]struct{}, len(participants))
for _, p := range participants {
addJIDForUSyncQuery(uniq, groupParticipantPhoneJID(ctx, client, p), p.JID)
}
return mapKeysToSlice(uniq)
}
func jidsForGetUserInfoWireJIDs(ctx context.Context, client *whatsmeow.Client, participants []types.GroupParticipantRequest) []types.JID {
uniq := make(map[types.JID]struct{}, len(participants))
for _, p := range participants {
addJIDForUSyncQuery(uniq, utils.ResolveLIDToPhone(ctx, p.JID, client), p.JID)
}
return mapKeysToSlice(uniq)
}
// addJIDForUSyncQuery registers the JID to send to GetUserInfo. Responses are usually keyed by @s.whatsapp.net;
// if lookup is still @lid, we keep the wire JID so the query can still run.
func addJIDForUSyncQuery(uniq map[types.JID]struct{}, lookup types.JID, wireJID types.JID) {
if lookup.Server != types.HiddenUserServer {
uniq[lookup] = struct{}{}
return
}
uniq[wireJID] = struct{}{}
}
func mapKeysToSlice(uniq map[types.JID]struct{}) []types.JID {
out := make([]types.JID, 0, len(uniq))
for j := range uniq {
out = append(out, j)
}
return out
}
// groupParticipantPhoneJID is the @s.whatsapp.net (or best-effort) JID for contact / user-info map lookups.
func groupParticipantPhoneJID(ctx context.Context, client *whatsmeow.Client, p types.GroupParticipant) types.JID {
if !p.PhoneNumber.IsEmpty() {
return p.PhoneNumber
}
return utils.ResolveLIDToPhone(ctx, p.JID, client)
}
// wireParticipantLookupAndPhone returns the JID to use for contact/user-info lookups and the phone user
// string for API output, using a single LID→PN resolution per participant.
func wireParticipantLookupAndPhone(ctx context.Context, client *whatsmeow.Client, wire types.JID) (lookupJID types.JID, phoneDigits string) {
resolved := utils.ResolveLIDToPhone(ctx, wire, client)
phoneDigits = resolved.User
if resolved.Server != types.HiddenUserServer {
return resolved, phoneDigits
}
return wire, phoneDigits
}
// groupParticipantPhoneUser is the numeric phone for API responses (digits), using PhoneNumber when LID resolution fails.
func groupParticipantPhoneUser(ctx context.Context, client *whatsmeow.Client, p types.GroupParticipant) string {
resolved := utils.ResolveLIDToPhone(ctx, p.JID, client)
if resolved.Server != types.HiddenUserServer {
return resolved.User
}
if !p.PhoneNumber.IsEmpty() {
return p.PhoneNumber.User
}
return resolved.User
}
func resolveParticipantDisplayName(ctx context.Context, client *whatsmeow.Client, seed string, lookupJID types.JID, wireJID types.JID, userInfo map[types.JID]types.UserInfo) string {
if seed != "" {
return seed
}
if s := contactDisplayName(ctx, client, lookupJID); s != "" {
return s
}
if s := verifiedNameFromUserInfo(userInfo[lookupJID]); s != "" {
return s
}
if wireJID != lookupJID {
if s := verifiedNameFromUserInfo(userInfo[wireJID]); s != "" {
return s
}
}
return ""
}
func contactDisplayName(ctx context.Context, client *whatsmeow.Client, jid types.JID) string {
if jid.IsEmpty() {
return ""
}
contact, err := client.Store.Contacts.GetContact(ctx, jid)
if err != nil || !contact.Found {
return ""
}
return contactInfoDisplayName(contact)
}
func contactInfoDisplayName(contact types.ContactInfo) string {
return whatsapp.PreferredContactDisplayName(contact, "")
}
func verifiedNameFromUserInfo(info types.UserInfo) string {
if info.VerifiedName != nil && info.VerifiedName.Details != nil {
return info.VerifiedName.Details.GetVerifiedName()
}
return ""
}