X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/3cdbd017da9ae7a7045f4272f16d4b262fd01c79..b1be0ee8530df5db8973bfe355f2f6d3149383a0:/whatsapp_send.go?ds=inline

diff --git a/whatsapp_send.go b/whatsapp_send.go
index d5995df..b95a82e 100644
--- a/whatsapp_send.go
+++ b/whatsapp_send.go
@@ -31,21 +31,24 @@ const (
 	whatsappFailed  = "failed"
 )
 
-// whatsappSend sends text to chat, the ID of a private chat or a group, and
-// returns the answer of the tool. id names the send: a call with an id that has
-// a record gives the answer of the record and sends nothing, and the same id
-// with another chat or text is an error. The record "sending" is durable before
-// the send, so a stop of the daemon during the send gives an answer that the
-// result is unknown, and not a second send. A disconnected WhatsApp sends
-// nothing and makes no record. link gives the device, the client, and the own
-// IDs, groups the names of the groups, and state the send records. The clock
-// gives the times of the records and the time zone of the answer.
-func whatsappSend(ctx context.Context, link WhatsAppLink, groups *WhatsAppGroups, state *WhatsAppState, clock func() time.Time, id, chat, text string) (string, error) {
+// whatsappSend sends text and an optional stored image to chat, the ID of a
+// private chat or a group, and returns the answer of the tool. id names the
+// send: a call with an id that has a record gives the answer of the record and
+// sends nothing, and the same id with another chat, text, or image is an error.
+// The record "sending" is durable before the send, so a stop of the daemon
+// during the send gives an answer that the result is unknown, and not a second
+// send. A disconnected WhatsApp sends nothing and makes no record. link gives
+// the device, the client, and the own IDs, groups the names of the groups, and
+// state the send records. The clock gives the times of the records and the time
+// zone of the answer. Image names are checked before the record is written, and
+// uploads start only after the record is durable. Text-only records keep their
+// text digest.
+func whatsappSend(ctx context.Context, link WhatsAppLink, groups *WhatsAppGroups, state *WhatsAppState, images *ImageStore, clock func() time.Time, id, chat, text, image string) (string, error) {
 	if !link.linked {
 		return whatsappNotLinked, nil
 	}
 
-	jid, err := whatsappSendCheck(id, chat, text, link.own)
+	jid, err := whatsappSendCheck(id, chat, text, image, link.own)
 	if err != nil {
 		return "", err
 	}
@@ -53,6 +56,7 @@ func whatsappSend(ctx context.Context, link WhatsAppLink, groups *WhatsAppGroups
 	digest := sha256.Sum256([]byte(text))
 	record := WhatsAppSend{
 		ID:     id,
+		Image:  image,
 		Chat:   chat,
 		Digest: hex.EncodeToString(digest[:]),
 		State:  whatsappSending,
@@ -61,7 +65,7 @@ func whatsappSend(ctx context.Context, link WhatsAppLink, groups *WhatsAppGroups
 
 	held, found := state.Send(id)
 	switch {
-	case found && (held.Chat != record.Chat || held.Digest != record.Digest):
+	case found && (held.Chat != record.Chat || held.Digest != record.Digest || held.Image != record.Image):
 		return "", fmt.Errorf("the id %s belongs to another message: give a new id for each message", id)
 	case found && held.State == whatsappSending:
 		return "The send with this id started, but its result is unknown, because the daemon stopped during it. Ask the user to look at the chat in WhatsApp before you send the message again with a new id.", nil
@@ -71,20 +75,39 @@ func whatsappSend(ctx context.Context, link WhatsAppLink, groups *WhatsAppGroups
 		return "", errors.New("WhatsApp is disconnected, so nothing was sent: try again later")
 	}
 
+	var data []byte
+
+	if image != "" {
+		data, err = images.Read(image)
+		if err != nil {
+			return "", fmt.Errorf("read image to send: %w", err)
+		}
+	}
+
 	record.MessageID = link.client.GenerateMessageID()
 	err = state.PutSend(record)
 	if err != nil {
 		return "", err
 	}
 
+	message := &waE2E.Message{Conversation: new(text)}
+	if image != "" {
+		message, err = whatsappImageMessage(ctx, link.client, data, text)
+	}
+
 	sendCtx, cancel := context.WithTimeout(ctx, whatsappSendTimeout)
 	defer cancel()
 
-	response, err := link.client.SendMessage(sendCtx, jid, &waE2E.Message{
-		Conversation: new(text),
-	}, whatsmeow.SendRequestExtra{
-		ID: record.MessageID,
-	})
+	var response whatsmeow.SendResponse
+
+	if err == nil {
+		response, err = link.client.SendMessage(sendCtx, jid, message, whatsmeow.SendRequestExtra{
+			ID: record.MessageID,
+		})
+		if err != nil && image != "" {
+			err = fmt.Errorf("send image: %w", whatsappImageSendError(err))
+		}
+	}
 
 	record.State = whatsappSent
 	if err != nil {
@@ -108,14 +131,14 @@ func whatsappSend(ctx context.Context, link WhatsAppLink, groups *WhatsAppGroups
 }
 
 // whatsappSendCheck returns the JID of chat, and an error when id, chat, or
-// text cannot go to a send. The chat is a private chat or a group, and not the
-// chat of the user with itself.
-func whatsappSendCheck(id, chat, text string, own []string) (types.JID, error) {
+// text cannot go to a send. Text can be empty only with an image. The chat is a
+// private chat or a group, and not the chat of the user with itself.
+func whatsappSendCheck(id, chat, text, image string, own []string) (types.JID, error) {
 	jid, err := types.ParseJID(chat)
 	switch {
 	case strings.TrimSpace(id) == "" || len(id) > whatsappSendIDBytes:
 		return types.EmptyJID, fmt.Errorf("the id must have 1 to %d bytes", whatsappSendIDBytes)
-	case strings.TrimSpace(text) == "" || len(text) > whatsappSendBytes:
+	case (strings.TrimSpace(text) == "" && image == "") || len(text) > whatsappSendBytes:
 		return types.EmptyJID, fmt.Errorf("the text must have 1 to %d bytes", whatsappSendBytes)
 	case err != nil || jid.User == "" || jid != jid.ToNonAD() || jid.String() != chat:
 		return types.EmptyJID, fmt.Errorf("%q is not the ID of a WhatsApp chat: find the ID with whatsapp_find", chat)