Hugging Face's logo

Spaces:
NitinBot002
/
waha
Runtime error

App Files Community
waha
File size: 3,937 Bytes 
4327358
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
 
import {
  areJidsSameUser,
  BinaryNode,
  getBinaryNodeChildren,
  getStatusFromReceiptType,
  isJidGroup,
  isJidStatusBroadcast,
  jidEncode,
  jidNormalizedUser,
  proto,
} from '@adiwajshing/baileys';

export interface ReceiptEvent {
  key: proto.IMessageKey;
  participant?: string;
  messageIds: string[];
  status: number;
  _node: any;
}

interface Me {
  id: string;
  lid?: string;
}

export function jid(field: any) {
  if (!field) {
    return field;
  }
  const data = field['$1'];
  if (!data) {
    return data;
  }

  let server = data.server;
  if (!server) {
    server =
      data.domainType === 0 || data.domainType === 128
        ? 's.whatsapp.net'
        : 'lid';
  }
  return jidEncode(data.user, server, data.device);
}

export function TagReceiptNodeToReceiptEvent(
  node: BinaryNode,
  me: Me,
): ReceiptEvent[] {
  const { attrs, content } = node;
  const status = getStatusFromReceiptType(attrs.type);
  if (status == null) {
    return [];
  }

  const from = jidNormalizedUser(jid(attrs.from));
  const participant = jidNormalizedUser(jid(attrs.participant));
  const recipient = jidNormalizedUser(jid(attrs.recipient));

  const isLid = from.includes('lid');
  const isNodeFromMe = areJidsSameUser(
    participant || from,
    isLid ? me?.lid : me?.id,
  );
  const remoteJid = !isNodeFromMe || isJidGroup(from) ? from : recipient;
  const fromMe = !recipient || (attrs.type === 'retry' && isNodeFromMe);

  // basically, we only want to know when a message from us has been delivered to/read by the other person
  // or another device of ours has read some messages
  if (status < proto.WebMessageInfo.Status.SERVER_ACK && isNodeFromMe) {
    return [];
  }

  const key: proto.IMessageKey = {
    remoteJid: remoteJid,
    id: '',
    fromMe: fromMe,
  };

  const ids = [attrs.id];
  if (Array.isArray(content)) {
    const items = getBinaryNodeChildren(content[0], 'item');
    ids.push(...items.map((i) => i.attrs.id));
  }

  if (isJidGroup(remoteJid) || isJidStatusBroadcast(remoteJid)) {
    if (participant) {
      key.participant = fromMe ? (isLid ? me.lid : me.id) : recipient;
      const eventParticipant = fromMe ? participant : isLid ? me.lid : me.id;
      return [
        {
          key: key,
          messageIds: ids,
          status: status as any,
          participant: eventParticipant,
          _node: node,
        },
      ];
    } else {
      // Handle grouped receipts
      return handleGroupedReceipts(node, key, status, fromMe, isLid, me);
    }
  }

  return [
    {
      key: key,
      messageIds: ids,
      status: status as any,
      _node: node,
    },
  ];
}

function handleGroupedReceipts(
  node: BinaryNode,
  key: proto.IMessageKey,
  status: number,
  fromMe: boolean,
  isLid: boolean,
  me: Me,
): ReceiptEvent[] {
  const { content } = node;
  if (!Array.isArray(content)) {
    return [];
  }
  const participantsTags = content.filter((c) => c.tag === 'participants');
  if (participantsTags.length === 0) {
    return [];
  }

  const receiptEvents: ReceiptEvent[] = [];

  for (const participants of participantsTags) {
    const participantKey = participants.attrs?.key;
    if (!participantKey) continue;

    const users = getBinaryNodeChildren(participants, 'user');
    for (const user of users) {
      const userAttrs = user.attrs;
      if (!userAttrs) continue;

      const userJid = jidNormalizedUser(jid(userAttrs.jid));
      if (!userJid) continue;

      key.participant = fromMe ? (isLid ? me.lid : me.id) : userJid;
      const eventParticipant = fromMe ? userJid : isLid ? me.lid : me.id;
      const receiptEvent: ReceiptEvent = {
        key: {
          ...key,
          id: participantKey,
        },
        messageIds: [participantKey],
        status: status as any,
        participant: eventParticipant,
        _node: node,
      };

      receiptEvents.push(receiptEvent);
    }
  }

  return receiptEvents;
}