slidge-whatsapp 0.2.5__cp311-cp311-manylinux_2_36_aarch64.whl → 0.3.0b0__cp311-cp311-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/group.go

@@ -13,6 +13,7 @@ import (
 	"strings"
 
 	waBinary "go.mau.fi/whatsmeow/binary"
+	"go.mau.fi/whatsmeow/store"
 	"go.mau.fi/whatsmeow/types"
 	"go.mau.fi/whatsmeow/types/events"
 )
@@ -38,6 +39,11 @@ type ReqCreateGroup struct {
 	// A create key can be provided to deduplicate the group create notification that will be triggered
 	// when the group is created. If provided, the JoinedGroup event will contain the same key.
 	CreateKey types.MessageID
+
+	types.GroupEphemeral
+	types.GroupAnnounce
+	types.GroupLocked
+	types.GroupMembershipApprovalMode
 	// Set IsParent to true to create a community instead of a normal group.
 	// When creating a community, the linked announcement group will be created automatically by the server.
 	types.GroupParent
@@ -48,13 +54,22 @@ type ReqCreateGroup struct {
 // CreateGroup creates a group on WhatsApp with the given name and participants.
 //
 // See ReqCreateGroup for parameters.
-func (cli *Client) CreateGroup(req ReqCreateGroup) (*types.GroupInfo, error) {
+func (cli *Client) CreateGroup(ctx context.Context, req ReqCreateGroup) (*types.GroupInfo, error) {
 	participantNodes := make([]waBinary.Node, len(req.Participants), len(req.Participants)+1)
 	for i, participant := range req.Participants {
 		participantNodes[i] = waBinary.Node{
 			Tag:   "participant",
 			Attrs: waBinary.Attrs{"jid": participant},
 		}
+		pt, err := cli.Store.PrivacyTokens.GetPrivacyToken(ctx, participant)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get privacy token for participant %s: %v", participant, err)
+		} else if pt != nil {
+			participantNodes[i].Content = []waBinary.Node{{
+				Tag:     "privacy",
+				Content: pt.Token,
+			}}
+		}
 	}
 	if req.CreateKey == "" {
 		req.CreateKey = cli.GenerateMessageID()
@@ -75,9 +90,33 @@ func (cli *Client) CreateGroup(req ReqCreateGroup) (*types.GroupInfo, error) {
 			Attrs: waBinary.Attrs{"jid": req.LinkedParentJID},
 		})
 	}
+	if req.IsLocked {
+		participantNodes = append(participantNodes, waBinary.Node{Tag: "locked"})
+	}
+	if req.IsAnnounce {
+		participantNodes = append(participantNodes, waBinary.Node{Tag: "announcement"})
+	}
+	if req.IsEphemeral {
+		participantNodes = append(participantNodes, waBinary.Node{
+			Tag: "ephemeral",
+			Attrs: waBinary.Attrs{
+				"expiration": req.DisappearingTimer,
+				"trigger":    "1", // TODO what's this?
+			},
+		})
+	}
+	if req.IsJoinApprovalRequired {
+		participantNodes = append(participantNodes, waBinary.Node{
+			Tag: "membership_approval_mode",
+			Content: []waBinary.Node{{
+				Tag:   "group_join",
+				Attrs: waBinary.Attrs{"state": "on"},
+			}},
+		})
+	}
 	// WhatsApp web doesn't seem to include the static prefix for these
 	key := strings.TrimPrefix(req.CreateKey, "3EB0")
-	resp, err := cli.sendGroupIQ(context.TODO(), iqSet, types.GroupServerJID, waBinary.Node{
+	resp, err := cli.sendGroupIQ(ctx, iqSet, types.GroupServerJID, waBinary.Node{
 		Tag: "create",
 		Attrs: waBinary.Attrs{
 			"subject": req.Name,
@@ -518,7 +557,14 @@ func (cli *Client) GetLinkedGroupsParticipants(community types.JID) ([]types.JID
 	if !ok {
 		return nil, &ElementMissingError{Tag: "linked_groups_participants", In: "response to community participants query"}
 	}
-	return parseParticipantList(&participants), nil
+	members, lidPairs := parseParticipantList(&participants)
+	if len(lidPairs) > 0 {
+		err = cli.Store.LIDs.PutManyLIDMappings(context.TODO(), lidPairs)
+		if err != nil {
+			cli.Log.Warnf("Failed to store LID mappings for community participants: %v", err)
+		}
+	}
+	return members, nil
 }
 
 // GetGroupInfo requests basic info about a group chat from the WhatsApp servers.
@@ -548,27 +594,43 @@ func (cli *Client) getGroupInfo(ctx context.Context, jid types.JID, lockParticip
 		return groupInfo, err
 	}
 	if lockParticipantCache {
-		cli.groupParticipantsCacheLock.Lock()
-		defer cli.groupParticipantsCacheLock.Unlock()
+		cli.groupCacheLock.Lock()
+		defer cli.groupCacheLock.Unlock()
 	}
 	participants := make([]types.JID, len(groupInfo.Participants))
+	lidPairs := make([]store.LIDMapping, len(groupInfo.Participants))
 	for i, part := range groupInfo.Participants {
 		participants[i] = part.JID
+		if !part.PhoneNumber.IsEmpty() && !part.LID.IsEmpty() {
+			lidPairs[i] = store.LIDMapping{
+				LID: part.LID,
+				PN:  part.PhoneNumber,
+			}
+		}
+	}
+	cli.groupCache[jid] = &groupMetaCache{
+		AddressingMode:             groupInfo.AddressingMode,
+		CommunityAnnouncementGroup: groupInfo.IsAnnounce && groupInfo.IsDefaultSubGroup,
+		Members:                    participants,
+	}
+	err = cli.Store.LIDs.PutManyLIDMappings(ctx, lidPairs)
+	if err != nil {
+		cli.Log.Warnf("Failed to store LID mappings for members of %s: %v", jid, err)
 	}
-	cli.groupParticipantsCache[jid] = participants
 	return groupInfo, nil
 }
 
-func (cli *Client) getGroupMembers(ctx context.Context, jid types.JID) ([]types.JID, error) {
-	cli.groupParticipantsCacheLock.Lock()
-	defer cli.groupParticipantsCacheLock.Unlock()
-	if _, ok := cli.groupParticipantsCache[jid]; !ok {
-		_, err := cli.getGroupInfo(ctx, jid, false)
-		if err != nil {
-			return nil, err
-		}
+func (cli *Client) getCachedGroupData(ctx context.Context, jid types.JID) (*groupMetaCache, error) {
+	cli.groupCacheLock.Lock()
+	defer cli.groupCacheLock.Unlock()
+	if val, ok := cli.groupCache[jid]; ok {
+		return val, nil
 	}
-	return cli.groupParticipantsCache[jid], nil
+	_, err := cli.getGroupInfo(ctx, jid, false)
+	if err != nil {
+		return nil, err
+	}
+	return cli.groupCache[jid], nil
 }
 
 func parseParticipant(childAG *waBinary.AttrUtility, child *waBinary.Node) types.GroupParticipant {
@@ -577,12 +639,14 @@ func parseParticipant(childAG *waBinary.AttrUtility, child *waBinary.Node) types
 		IsAdmin:      pcpType == "admin" || pcpType == "superadmin",
 		IsSuperAdmin: pcpType == "superadmin",
 		JID:          childAG.JID("jid"),
-		LID:          childAG.OptionalJIDOrEmpty("lid"),
 		DisplayName:  childAG.OptionalString("display_name"),
 	}
-	if participant.JID.Server == types.HiddenUserServer && participant.LID.IsEmpty() {
+	if participant.JID.Server == types.HiddenUserServer {
 		participant.LID = participant.JID
-		//participant.JID = types.EmptyJID
+		participant.PhoneNumber = childAG.OptionalJIDOrEmpty("phone_number")
+	} else if participant.JID.Server == types.DefaultUserServer {
+		participant.PhoneNumber = participant.JID
+		participant.LID = childAG.OptionalJIDOrEmpty("lid")
 	}
 	if errorCode := childAG.OptionalInt("error"); errorCode != 0 {
 		participant.Error = errorCode
@@ -604,15 +668,19 @@ func (cli *Client) parseGroupNode(groupNode *waBinary.Node) (*types.GroupInfo, e
 
 	group.JID = types.NewJID(ag.String("id"), types.GroupServer)
 	group.OwnerJID = ag.OptionalJIDOrEmpty("creator")
+	group.OwnerPN = ag.OptionalJIDOrEmpty("creator_pn")
 
 	group.Name = ag.String("subject")
 	group.NameSetAt = ag.UnixTime("s_t")
 	group.NameSetBy = ag.OptionalJIDOrEmpty("s_o")
+	group.NameSetByPN = ag.OptionalJIDOrEmpty("s_o_pn")
 
 	group.GroupCreated = ag.UnixTime("creation")
+	group.CreatorCountryCode = ag.OptionalString("creator_country_code")
 
 	group.AnnounceVersionID = ag.OptionalString("a_v_id")
 	group.ParticipantVersionID = ag.OptionalString("p_v_id")
+	group.AddressingMode = types.AddressingMode(ag.OptionalString("addressing_mode"))
 
 	for _, child := range groupNode.GetChildren() {
 		childAG := child.AttrGetter()
@@ -626,6 +694,7 @@ func (cli *Client) parseGroupNode(groupNode *waBinary.Node) (*types.GroupInfo, e
 				group.Topic = string(topicBytes)
 				group.TopicID = childAG.String("id")
 				group.TopicSetBy = childAG.OptionalJIDOrEmpty("participant")
+				group.TopicSetByPN = childAG.OptionalJIDOrEmpty("participant_pn") // TODO confirm field name
 				group.TopicSetAt = childAG.UnixTime("t")
 			}
 		case "announcement":
@@ -678,7 +747,7 @@ func parseGroupLinkTargetNode(groupNode *waBinary.Node) (types.GroupLinkTarget,
 	}, ag.Error()
 }
 
-func parseParticipantList(node *waBinary.Node) (participants []types.JID) {
+func parseParticipantList(node *waBinary.Node) (participants []types.JID, lidPairs []store.LIDMapping) {
 	children := node.GetChildren()
 	participants = make([]types.JID, 0, len(children))
 	for _, child := range children {
@@ -687,55 +756,87 @@ func parseParticipantList(node *waBinary.Node) (participants []types.JID) {
 			continue
 		}
 		participants = append(participants, jid)
+		if jid.Server == types.HiddenUserServer {
+			phoneNumber, ok := child.Attrs["phone_number"].(types.JID)
+			if ok && !phoneNumber.IsEmpty() {
+				lidPairs = append(lidPairs, store.LIDMapping{
+					LID: jid,
+					PN:  phoneNumber,
+				})
+			}
+		} else if jid.Server == types.DefaultUserServer {
+			lid, ok := child.Attrs["lid"].(types.JID)
+			if ok && !lid.IsEmpty() {
+				lidPairs = append(lidPairs, store.LIDMapping{
+					LID: lid,
+					PN:  jid,
+				})
+			}
+		}
 	}
 	return
 }
 
-func (cli *Client) parseGroupCreate(node *waBinary.Node) (*events.JoinedGroup, error) {
+func (cli *Client) parseGroupCreate(parentNode, node *waBinary.Node) (*events.JoinedGroup, []store.LIDMapping, error) {
 	groupNode, ok := node.GetOptionalChildByTag("group")
 	if !ok {
-		return nil, fmt.Errorf("group create notification didn't contain group info")
+		return nil, nil, fmt.Errorf("group create notification didn't contain group info")
 	}
 	var evt events.JoinedGroup
+	pag := parentNode.AttrGetter()
 	ag := node.AttrGetter()
 	evt.Reason = ag.OptionalString("reason")
 	evt.CreateKey = ag.OptionalString("key")
 	evt.Type = ag.OptionalString("type")
+	evt.Sender = pag.OptionalJID("participant")
+	evt.SenderPN = pag.OptionalJID("participant_pn")
+	evt.Notify = pag.OptionalString("notify")
 	info, err := cli.parseGroupNode(&groupNode)
 	if err != nil {
-		return nil, fmt.Errorf("failed to parse group info in create notification: %w", err)
+		return nil, nil, fmt.Errorf("failed to parse group info in create notification: %w", err)
 	}
 	evt.GroupInfo = *info
-	return &evt, nil
+	lidPairs := make([]store.LIDMapping, 0, len(info.Participants))
+	for _, pcp := range info.Participants {
+		if !pcp.PhoneNumber.IsEmpty() && !pcp.LID.IsEmpty() {
+			lidPairs = append(lidPairs, store.LIDMapping{
+				LID: pcp.LID,
+				PN:  pcp.PhoneNumber,
+			})
+		}
+	}
+	return &evt, lidPairs, nil
 }
 
-func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, error) {
+func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, []store.LIDMapping, error) {
 	var evt events.GroupInfo
 	ag := node.AttrGetter()
 	evt.JID = ag.JID("from")
 	evt.Notify = ag.OptionalString("notify")
 	evt.Sender = ag.OptionalJID("participant")
+	evt.SenderPN = ag.OptionalJID("participant_pn")
 	evt.Timestamp = ag.UnixTime("t")
 	if !ag.OK() {
-		return nil, fmt.Errorf("group change doesn't contain required attributes: %w", ag.Error())
+		return nil, nil, fmt.Errorf("group change doesn't contain required attributes: %w", ag.Error())
 	}
 
+	var lidPairs []store.LIDMapping
 	for _, child := range node.GetChildren() {
 		cag := child.AttrGetter()
 		if child.Tag == "add" || child.Tag == "remove" || child.Tag == "promote" || child.Tag == "demote" {
-			evt.PrevParticipantVersionID = cag.String("prev_v_id")
-			evt.ParticipantVersionID = cag.String("v_id")
+			evt.PrevParticipantVersionID = cag.OptionalString("prev_v_id")
+			evt.ParticipantVersionID = cag.OptionalString("v_id")
 		}
 		switch child.Tag {
 		case "add":
 			evt.JoinReason = cag.OptionalString("reason")
-			evt.Join = parseParticipantList(&child)
+			evt.Join, lidPairs = parseParticipantList(&child)
 		case "remove":
-			evt.Leave = parseParticipantList(&child)
+			evt.Leave, lidPairs = parseParticipantList(&child)
 		case "promote":
-			evt.Promote = parseParticipantList(&child)
+			evt.Promote, lidPairs = parseParticipantList(&child)
 		case "demote":
-			evt.Demote = parseParticipantList(&child)
+			evt.Demote, lidPairs = parseParticipantList(&child)
 		case "locked":
 			evt.Locked = &types.GroupLocked{IsLocked: true}
 		case "unlocked":
@@ -744,9 +845,10 @@ func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, err
 			evt.Delete = &types.GroupDelete{Deleted: true, DeleteReason: cag.String("reason")}
 		case "subject":
 			evt.Name = &types.GroupName{
-				Name:      cag.String("subject"),
-				NameSetAt: cag.UnixTime("s_t"),
-				NameSetBy: cag.OptionalJIDOrEmpty("s_o"),
+				Name:        cag.String("subject"),
+				NameSetAt:   cag.UnixTime("s_t"),
+				NameSetBy:   cag.OptionalJIDOrEmpty("s_o"),
+				NameSetByPN: cag.OptionalJIDOrEmpty("s_o_pn"),
 			}
 		case "description":
 			var topicStr string
@@ -755,7 +857,7 @@ func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, err
 				topicChild := child.GetChildByTag("body")
 				topicBytes, ok := topicChild.Content.([]byte)
 				if !ok {
-					return nil, fmt.Errorf("group change description has unexpected body: %s", topicChild.XMLString())
+					return nil, nil, fmt.Errorf("group change description has unexpected body: %s", topicChild.XMLString())
 				}
 				topicStr = string(topicBytes)
 			}
@@ -797,12 +899,12 @@ func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, err
 			}
 			groupNode, ok := child.GetOptionalChildByTag("group")
 			if !ok {
-				return nil, &ElementMissingError{Tag: "group", In: "group link"}
+				return nil, nil, &ElementMissingError{Tag: "group", In: "group link"}
 			}
 			var err error
 			evt.Link.Group, err = parseGroupLinkTargetNode(&groupNode)
 			if err != nil {
-				return nil, fmt.Errorf("failed to parse group link node in group change: %w", err)
+				return nil, nil, fmt.Errorf("failed to parse group link node in group change: %w", err)
 			}
 		case "unlink":
 			evt.Unlink = &types.GroupLinkChange{
@@ -811,12 +913,12 @@ func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, err
 			}
 			groupNode, ok := child.GetOptionalChildByTag("group")
 			if !ok {
-				return nil, &ElementMissingError{Tag: "group", In: "group unlink"}
+				return nil, nil, &ElementMissingError{Tag: "group", In: "group unlink"}
 			}
 			var err error
 			evt.Unlink.Group, err = parseGroupLinkTargetNode(&groupNode)
 			if err != nil {
-				return nil, fmt.Errorf("failed to parse group unlink node in group change: %w", err)
+				return nil, nil, fmt.Errorf("failed to parse group unlink node in group change: %w", err)
 			}
 		case "membership_approval_mode":
 			evt.MembershipApprovalMode = &types.GroupMembershipApprovalMode{
@@ -826,54 +928,54 @@ func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, err
 			evt.UnknownChanges = append(evt.UnknownChanges, &child)
 		}
 		if !cag.OK() {
-			return nil, fmt.Errorf("group change %s element doesn't contain required attributes: %w", child.Tag, cag.Error())
+			return nil, nil, fmt.Errorf("group change %s element doesn't contain required attributes: %w", child.Tag, cag.Error())
 		}
 	}
-	return &evt, nil
+	return &evt, lidPairs, nil
 }
 
 func (cli *Client) updateGroupParticipantCache(evt *events.GroupInfo) {
+	// TODO can the addressing mode change here?
 	if len(evt.Join) == 0 && len(evt.Leave) == 0 {
 		return
 	}
-	cli.groupParticipantsCacheLock.Lock()
-	defer cli.groupParticipantsCacheLock.Unlock()
-	cached, ok := cli.groupParticipantsCache[evt.JID]
+	cli.groupCacheLock.Lock()
+	defer cli.groupCacheLock.Unlock()
+	cached, ok := cli.groupCache[evt.JID]
 	if !ok {
 		return
 	}
 Outer:
 	for _, jid := range evt.Join {
-		for _, existingJID := range cached {
+		for _, existingJID := range cached.Members {
 			if jid == existingJID {
 				continue Outer
 			}
 		}
-		cached = append(cached, jid)
+		cached.Members = append(cached.Members, jid)
 	}
 	for _, jid := range evt.Leave {
-		for i, existingJID := range cached {
+		for i, existingJID := range cached.Members {
 			if existingJID == jid {
-				cached[i] = cached[len(cached)-1]
-				cached = cached[:len(cached)-1]
+				cached.Members[i] = cached.Members[len(cached.Members)-1]
+				cached.Members = cached.Members[:len(cached.Members)-1]
 				break
 			}
 		}
 	}
-	cli.groupParticipantsCache[evt.JID] = cached
 }
 
-func (cli *Client) parseGroupNotification(node *waBinary.Node) (any, error) {
+func (cli *Client) parseGroupNotification(node *waBinary.Node) (any, []store.LIDMapping, error) {
 	children := node.GetChildren()
 	if len(children) == 1 && children[0].Tag == "create" {
-		return cli.parseGroupCreate(&children[0])
+		return cli.parseGroupCreate(node, &children[0])
 	} else {
-		groupChange, err := cli.parseGroupChange(node)
+		groupChange, lidPairs, err := cli.parseGroupChange(node)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 		cli.updateGroupParticipantCache(groupChange)
-		return groupChange, nil
+		return groupChange, lidPairs, nil
 	}
 }