Group.pm

filter: Statementstmt 91.6% 22 / 24 Branchbran n/a Conditioncond n/a MC/DCmcdc n/a Subroutinesub 100% 8 / 8 Podpod n/a totaltotal 93.7% 30 / 32 CC 1 SCAR 0.4
CC
1
Cov
92%
BEGIN
1.3
BEGIN
1.0
BEGIN
1.0
CRAP 1.0
« Event.pm ↑ Summary
1 package Net::Nostr::Group;
2  
3 1 ▶use strictures 2;
Subroutine BEGIN: called CC=1 SCAR=0.0
4  
5 1 ▶use Net::Nostr::_ConstructorArgs ();
Subroutine BEGIN: called CC=1 SCAR=0.0
6  
7 1 ▶use Carp qw(croak);
Subroutine BEGIN: called CC=1 SCAR=0.0
8 1 ▶use Encode ();
Subroutine BEGIN: called CC=1 SCAR=0.0
9 1 ▶use URI::Escape ();
Subroutine BEGIN: called CC=1 SCAR=0.0
10 1 ▶use Scalar::Util qw(blessed);
Subroutine BEGIN: called CC=1 SCAR=0.0
11 1 ▶use Net::Nostr::Bech32 qw(encode_naddr decode_naddr);
Subroutine BEGIN: called CC=1 SCAR=0.0
12 0 ▶use Net::Nostr::Event;
Subroutine BEGIN: called CC=1 SCAR=2.6
13  
14 my $HEX64 = qr/\A[0-9a-f]{64}\z/;
15  
16 sub parse_id {
17 my ($class, $str) = @_;
18 croak 'group identifier must be a non-empty string'
19 unless defined($str) && !ref($str) && length($str);
20 my ($base, $query) = split /\?/, $str, 2;
21 my $invite;
22 if (defined $query) {
23 croak 'invalid invite suffix'
24 unless $query =~ /\Ainvite=([^&#\s]+)\z/ && $query !~ /%(?![0-9A-Fa-f]{2})/;
25 my $encoded = $1;
26 $encoded =~ tr/+/ /;
27 my $bytes = URI::Escape::uri_unescape($encoded);
28 $invite = eval { Encode::decode('UTF-8', $bytes, Encode::FB_CROAK()) };
29 croak 'invite must be valid UTF-8' if $@;
30 _validate_invite($invite);
31 }
32 my $data = decode_naddr($base);
33 croak "group identifier MUST reference kind 39000 metadata"
34 unless $data->{kind} == 39000;
35 croak 'group identifier requires a non-empty group id'
36 unless $class->validate_group_id($data->{identifier});
37 return {
38 group_id => $data->{identifier},
39 pubkey => $data->{pubkey},
40 kind => $data->{kind},
41 relays => $data->{relays},
42 relay => $data->{relays}[0],
43 (defined($invite) ? (invite => $invite) : ()),
44 };
45 }
46  
47 sub format_id {
48 my $class = shift;
49 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
50 my %known = map { $_ => 1 } qw(pubkey group_id relay relays invite);
51 croak 'unknown group reference argument' if grep { !$known{$_} } keys %args;
52 my $pubkey = $args{pubkey} // croak "format_id requires 'pubkey'";
53 my $group_id = $args{group_id} // croak "format_id requires 'group_id'";
54 croak 'group_id must be a non-empty string' unless $class->validate_group_id($group_id);
55 my @relays;
56 push @relays, $args{relay} if defined $args{relay};
57 if (defined $args{relays}) {
58 croak "relays must be an array reference"
59 unless ref $args{relays} eq 'ARRAY';
60 push @relays, @{$args{relays}};
61 }
62 my $identifier = encode_naddr(
63 identifier => $group_id,
64 pubkey => $pubkey,
65 kind => 39000,
66 relays => \@relays,
67 );
68 if (exists $args{invite}) {
69 _validate_invite($args{invite});
70 $identifier .= '?invite=' . URI::Escape::uri_escape_utf8($args{invite});
71 }
72 return $identifier;
73 }
74  
75 sub _validate_invite {
76 my ($code) = @_;
77 croak 'invite must be a non-empty string without control characters'
78 unless defined($code) && !ref($code) && length($code) && $code !~ /[[:cntrl:]]/;
79 }
80  
81 sub validate_group_id {
82 my ($class, $id) = @_;
83 return defined $id && !ref($id) && length($id) ? 1 : 0;
84 }
85  
86 sub _validate_and_extract_group {
87 my $class = shift;
88 my $method = shift;
89 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
90 my $pubkey = $args{pubkey} // croak "$method requires 'pubkey'";
91 my $group_id = $args{group_id} // croak "$method requires 'group_id'";
92 croak "invalid group_id: must be a non-empty string"
93 unless $class->validate_group_id($group_id);
94 return ($pubkey, $group_id);
95 }
96  
97 sub _build_tags_with_h {
98 my ($class, $group_id, $previous) = @_;
99 my @tags = (['h', $group_id]);
100 _validate_previous($previous) if defined $previous;
101 if (defined($previous) && @$previous) {
102 push @tags, ['previous', @$previous];
103 }
104 return @tags;
105 }
106  
107 sub _validate_previous {
108 my ($previous) = @_;
109 croak 'previous must be an array of eight-character lowercase hex references'
110 unless ref($previous) eq 'ARRAY';
111 for my $prefix (@$previous) {
112 croak 'previous must contain eight-character lowercase hex references'
113 unless defined($prefix) && !ref($prefix) && $prefix =~ /\A[0-9a-f]{8}\z/;
114 }
115 }
116  
117 # Kind 9000: put-user
118 sub put_user {
119 my $class = shift;
120 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
121 my ($pubkey, $group_id) = $class->_validate_and_extract_group('put_user', %args);
122 my $target = $args{target} // croak "put_user requires 'target'";
123 croak "target must be 64-char lowercase hex" unless $target =~ $HEX64;
124 my $roles = $args{roles};
125 my $reason = $args{reason} // '';
126  
127 my @tags = $class->_build_tags_with_h($group_id, $args{previous});
128 if ($roles && @$roles) {
129 push @tags, ['p', $target, @$roles];
130 } else {
131 push @tags, ['p', $target];
132 }
133  
134 delete @args{qw(group_id target roles reason previous)};
135 return Net::Nostr::Event->new(%args, kind => 9000, content => $reason, tags => \@tags);
136 }
137  
138 # Kind 9001: remove-user
139 sub remove_user {
140 my $class = shift;
141 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
142 my ($pubkey, $group_id) = $class->_validate_and_extract_group('remove_user', %args);
143 my $target = $args{target} // croak "remove_user requires 'target'";
144 croak "target must be 64-char lowercase hex" unless $target =~ $HEX64;
145 my $reason = $args{reason} // '';
146  
147 my @tags = $class->_build_tags_with_h($group_id, $args{previous});
148 push @tags, ['p', $target];
149  
150 delete @args{qw(group_id target reason previous)};
151 return Net::Nostr::Event->new(%args, kind => 9001, content => $reason, tags => \@tags);
152 }
153  
154 # Kind 9002: edit-metadata
155 sub _extra_metadata_tags {
156 my ($class, $group_id, $args) = @_;
157 my @tags;
158 if (exists $args->{banner}) {
159 croak 'banner must be a string' unless defined($args->{banner}) && !ref($args->{banner});
160 push @tags, ['banner', $args->{banner}];
161 }
162 if (exists $args->{parent}) {
163 croak 'parent must be a non-empty group id distinct from this group'
164 unless $class->validate_group_id($args->{parent}) && $args->{parent} ne $group_id;
165 push @tags, ['parent', $args->{parent}];
166 }
167 if (exists $args->{children}) {
168 croak 'children must be an array of distinct group ids' unless ref($args->{children}) eq 'ARRAY';
169 my %seen;
170 for my $child (@{$args->{children}}) {
171 croak 'child must be a distinct non-empty group id, not this group'
172 unless $class->validate_group_id($child) && $child ne $group_id && !$seen{$child}++;
173 push @tags, ['child', $child];
174 }
175 }
176 return @tags;
177 }
178  
179 sub _metadata_tags {
180 my ($class, $group_id, $args, $edit) = @_;
181 croak 'group_id must be a non-empty string' unless $class->validate_group_id($group_id);
182 my @tags;
183 for my $name (qw(name picture about)) {
184 next unless exists $args->{$name};
185 croak "$name must be a string" unless defined($args->{$name}) && !ref($args->{$name});
186 push @tags, [$name, $args->{$name}];
187 }
188 push @tags, $class->_extra_metadata_tags($group_id, $args);
189 my @flags = $edit ? qw(private closed unrestricted open visible public restricted hidden livekit)
190 : qw(livekit private restricted hidden closed);
191 for my $flag (@flags) {
192 next unless exists $args->{$flag};
193 croak "$flag must be 0 or 1" unless defined($args->{$flag}) && !ref($args->{$flag})
194 && $args->{$flag} =~ /\A[01]\z/;
195 push @tags, [$flag] if $args->{$flag};
196 }
197 for my $pair ([qw(private public)], [qw(closed open)], [qw(hidden visible)], [qw(restricted unrestricted)]) {
198 croak "conflicting $pair->[0] and $pair->[1] flags" if $args->{$pair->[0]} && $args->{$pair->[1]};
199 }
200 if (exists $args->{supported_kinds}) {
201 croak 'supported_kinds must be an array reference' unless ref($args->{supported_kinds}) eq 'ARRAY';
202 for my $kind (@{$args->{supported_kinds}}) {
203 croak 'supported_kinds must contain integers from 0 through 65535'
204 unless defined($kind) && !ref($kind) && $kind =~ /\A[0-9]+\z/ && $kind <= 65535;
205 }
206 push @tags, ['supported_kinds', map { "$_" } @{$args->{supported_kinds}}];
207 }
208 return @tags;
209 }
210  
211 sub edit_metadata {
212 my $class = shift;
213 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
214 my ($pubkey, $group_id) = $class->_validate_and_extract_group('edit_metadata', %args);
215 my $reason = $args{reason} // '';
216  
217 my @tags = $class->_build_tags_with_h($group_id, $args{previous});
218  
219 push @tags, $class->_metadata_tags($group_id, \%args, 1);
220  
221 delete @args{qw(group_id reason previous name picture about banner parent children
222 private closed unrestricted open visible public restricted hidden livekit supported_kinds)};
223 return Net::Nostr::Event->new(%args, kind => 9002, content => $reason, tags => \@tags);
224 }
225  
226 # Kind 9005: delete-event
227 sub delete_event {
228 my $class = shift;
229 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
230 my ($pubkey, $group_id) = $class->_validate_and_extract_group('delete_event', %args);
231 my $event_id = $args{event_id} // croak "delete_event requires 'event_id'";
232 croak "event_id must be 64-char lowercase hex" unless $event_id =~ $HEX64;
233 my $reason = $args{reason} // '';
234  
235 my @tags = $class->_build_tags_with_h($group_id, $args{previous});
236 push @tags, ['e', $event_id];
237  
238 delete @args{qw(group_id event_id reason previous)};
239 return Net::Nostr::Event->new(%args, kind => 9005, content => $reason, tags => \@tags);
240 }
241  
242 # Kind 9007: create-group
243 sub create_group {
244 my $class = shift;
245 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
246 my ($pubkey, $group_id) = $class->_validate_and_extract_group('create_group', %args);
247 my $reason = $args{reason} // '';
248  
249 my @tags = $class->_build_tags_with_h($group_id, $args{previous});
250  
251 delete @args{qw(group_id reason previous)};
252 return Net::Nostr::Event->new(%args, kind => 9007, content => $reason, tags => \@tags);
253 }
254  
255 # Kind 9008: delete-group
256 sub delete_group {
257 my $class = shift;
258 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
259 my ($pubkey, $group_id) = $class->_validate_and_extract_group('delete_group', %args);
260 my $reason = $args{reason} // '';
261  
262 my @tags = $class->_build_tags_with_h($group_id, $args{previous});
263  
264 delete @args{qw(group_id reason previous)};
265 return Net::Nostr::Event->new(%args, kind => 9008, content => $reason, tags => \@tags);
266 }
267  
268 # Kind 9009: create-invite
269 sub create_invite {
270 my $class = shift;
271 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
272 my ($pubkey, $group_id) = $class->_validate_and_extract_group('create_invite', %args);
273 my $code = $args{code} // croak "create_invite requires 'code'";
274 my $reason = $args{reason} // '';
275  
276 my @tags = $class->_build_tags_with_h($group_id, $args{previous});
277 push @tags, ['code', $code];
278  
279 delete @args{qw(group_id code reason previous)};
280 return Net::Nostr::Event->new(%args, kind => 9009, content => $reason, tags => \@tags);
281 }
282  
283 # Kind 9021: join-request
284 sub join_request {
285 my $class = shift;
286 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
287 my ($pubkey, $group_id) = $class->_validate_and_extract_group('join_request', %args);
288 my $reason = $args{reason} // '';
289  
290 my @tags = $class->_build_tags_with_h($group_id, $args{previous});
291 push @tags, ['code', $args{code}] if defined $args{code};
292  
293 delete @args{qw(group_id reason previous code)};
294 return Net::Nostr::Event->new(%args, kind => 9021, content => $reason, tags => \@tags);
295 }
296  
297 # Kind 9022: leave-request
298 sub leave_request {
299 my $class = shift;
300 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
301 my ($pubkey, $group_id) = $class->_validate_and_extract_group('leave_request', %args);
302 my $reason = $args{reason} // '';
303  
304 my @tags = $class->_build_tags_with_h($group_id, $args{previous});
305  
306 delete @args{qw(group_id reason previous)};
307 return Net::Nostr::Event->new(%args, kind => 9022, content => $reason, tags => \@tags);
308 }
309  
310 # Kind 39000: group metadata (relay-generated, addressable)
311 sub metadata {
312 my $class = shift;
313 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
314 my $pubkey = $args{pubkey} // croak "metadata requires 'pubkey'";
315 my $group_id = $args{group_id} // croak "metadata requires 'group_id'";
316  
317 my @tags = (['d', $group_id]);
318  
319 push @tags, $class->_metadata_tags($group_id, \%args, 0);
320  
321 delete @args{qw(group_id name picture about banner parent children livekit supported_kinds
322 private restricted hidden closed)};
323 return Net::Nostr::Event->new(%args, kind => 39000, content => '', tags => \@tags);
324 }
325  
326 # Kind 39001: group admins (relay-generated, addressable)
327 sub admins {
328 my $class = shift;
329 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
330 my $pubkey = $args{pubkey} // croak "admins requires 'pubkey'";
331 my $group_id = $args{group_id} // croak "admins requires 'group_id'";
332 my $members = $args{members} // croak "admins requires 'members'";
333 my $content = $args{content} // '';
334  
335 my @tags = (['d', $group_id]);
336 for my $member (@$members) {
337 croak "member pubkey must be 64-char lowercase hex" unless $member->{pubkey} =~ $HEX64;
338 push @tags, ['p', $member->{pubkey}, @{$member->{roles}}];
339 }
340  
341 delete @args{qw(group_id members content)};
342 return Net::Nostr::Event->new(%args, kind => 39001, content => $content, tags => \@tags);
343 }
344  
345 # Kind 39002: group members (relay-generated, addressable)
346 sub members {
347 my $class = shift;
348 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
349 my $pubkey = $args{pubkey} // croak "members requires 'pubkey'";
350 my $group_id = $args{group_id} // croak "members requires 'group_id'";
351 my $members = $args{members} // croak "members requires 'members'";
352 my $content = $args{content} // '';
353  
354 my @tags = (['d', $group_id]);
355 for (@$members) {
356 croak "member pubkey must be 64-char lowercase hex" unless $_ =~ $HEX64;
357 push @tags, ['p', $_];
358 }
359  
360 delete @args{qw(group_id members content)};
361 return Net::Nostr::Event->new(%args, kind => 39002, content => $content, tags => \@tags);
362 }
363  
364 # Kind 39003: group roles (relay-generated, addressable)
365 sub roles {
366 my $class = shift;
367 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
368 my $pubkey = $args{pubkey} // croak "roles requires 'pubkey'";
369 my $group_id = $args{group_id} // croak "roles requires 'group_id'";
370 my $roles = $args{roles} // croak "roles requires 'roles'";
371 my $content = $args{content} // '';
372  
373 my @tags = (['d', $group_id]);
374 for my $role (@$roles) {
375 if (defined $role->{description}) {
376 push @tags, ['role', $role->{name}, $role->{description}];
377 } else {
378 push @tags, ['role', $role->{name}];
379 }
380 }
381  
382 delete @args{qw(group_id roles content)};
383 return Net::Nostr::Event->new(%args, kind => 39003, content => $content, tags => \@tags);
384 }
385  
386 # Kind 39004: livekit participants (relay-generated, addressable)
387 sub participants {
388 my $class = shift;
389 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
390 my $pubkey = $args{pubkey} // croak "participants requires 'pubkey'";
391 my $group_id = $args{group_id} // croak "participants requires 'group_id'";
392 my $participants = $args{participants} // croak "participants requires 'participants'";
393 my $content = $args{content} // '';
394 croak "participants must be an array reference"
395 unless ref $participants eq 'ARRAY';
396  
397 my @tags = (['d', $group_id]);
398 for my $participant (@$participants) {
399 croak "participant pubkey must be 64-char lowercase hex"
400 unless $participant =~ $HEX64;
401 push @tags, ['participant', $participant];
402 }
403  
404 delete @args{qw(group_id participants content)};
405 return Net::Nostr::Event->new(%args, kind => 39004, content => $content, tags => \@tags);
406 }
407  
408 # Parsing methods
409  
410 sub _validate_pins {
411 my ($pins) = @_;
412 croak 'pins must be an array reference' unless ref($pins) eq 'ARRAY';
413 for my $pin (@$pins) {
414 croak 'pin must contain a tag name and reference'
415 unless ref($pin) eq 'ARRAY' && @$pin == 2 && defined($pin->[0])
416 && !ref($pin->[0]) && defined($pin->[1]) && !ref($pin->[1]);
417 if ($pin->[0] eq 'e') {
418 croak 'pin event id must be 64-char lowercase hex' unless $pin->[1] =~ $HEX64;
419 } elsif ($pin->[0] eq 'a') {
420 croak 'pin address must identify an addressable event'
421 unless $pin->[1] =~ /\A(3[0-9]{4}):([0-9a-f]{64}):(.*)\z/s;
422 } else {
423 croak 'pin tag must be e or a';
424 }
425 }
426 }
427  
428 sub _pin_event {
429 my $class = shift;
430 my $kind = shift;
431 my %args = Net::Nostr::_ConstructorArgs::normalize(@_);
432 my (undef, $group_id) = $class->_validate_and_extract_group('pin list', %args);
433 _validate_pins($args{pins});
434 my @tags = ([$kind == 9010 ? 'h' : 'd', $group_id], map { [@$_] } @{$args{pins}});
435 if ($kind == 9010 && exists $args{previous}) {
436 _validate_previous($args{previous});
437 push @tags, ['previous', @{$args{previous}}];
438 }
439 my $reason = delete $args{reason} // '';
440 delete @args{qw(group_id pins previous)};
441 return Net::Nostr::Event->new(%args, kind=>$kind, content=>$kind == 9010 ? $reason : '', tags=>\@tags);
442 }
443  
444 sub update_pin_list {
445 my $class = shift;
446 return $class->_pin_event(9010, Net::Nostr::_ConstructorArgs::normalize(@_));
447 }
448  
449 sub pinned_events {
450 my $class = shift;
451 return $class->_pin_event(39005, Net::Nostr::_ConstructorArgs::normalize(@_));
452 }
453  
454 sub pins_from_event {
455 my ($class, $event) = @_;
456 croak 'pin event must be a Net::Nostr::Event' unless blessed($event) && $event->isa('Net::Nostr::Event');
457 croak 'pin event must be kind 9010 or 39005' unless $event->kind == 9010 || $event->kind == 39005;
458 my $id_tag = $event->kind == 9010 ? 'h' : 'd';
459 my (@ids, @pins);
460 for my $tag (@{$event->tags}) {
461 croak 'pin tag requires a name' unless @$tag && defined($tag->[0]);
462 if ($tag->[0] eq $id_tag) {
463 croak 'pin group tag must have one value' unless @$tag == 2;
464 push @ids, $tag->[1];
465 } elsif ($tag->[0] eq 'e' || $tag->[0] eq 'a') {
466 push @pins, [@$tag];
467 } elsif ($tag->[0] eq 'previous') {
468 _validate_previous([@$tag[1 .. $#$tag]]);
469 } else {
470 croak 'unknown pin tag';
471 }
472 }
473 croak 'pin event requires exactly one non-empty group id'
474 unless @ids == 1 && $class->validate_group_id($ids[0]);
475 _validate_pins(\@pins);
476 return {group_id=>$ids[0], pins=>\@pins};
477 }
478  
479 sub metadata_from_event {
480 my ($class, $event) = @_;
481 croak 'metadata event must be a Net::Nostr::Event' unless blessed($event) && $event->isa('Net::Nostr::Event');
482 croak "event must be kind 39000" unless $event->kind == 39000;
483  
484 my (%meta, %seen);
485 my %flags = map { $_ => 1 } qw(private restricted hidden closed livekit);
486 my %values = map { $_ => 1 } qw(d name picture about banner parent);
487  
488 for my $tag (@{$event->tags}) {
489 my $name = $tag->[0];
490 croak 'metadata tag requires a name' unless defined $name;
491 if ($values{$name}) {
492 croak "$name must have one value and occur at most once" unless @$tag == 2 && !$seen{$name}++;
493 $meta{$name eq 'd' ? 'group_id' : $name} = $tag->[1];
494 } elsif ($name eq 'child') {
495 croak 'child tag must have one value' unless @$tag == 2;
496 push @{$meta{children}}, $tag->[1];
497 } elsif ($name eq 'supported_kinds') {
498 croak 'supported_kinds must occur at most once' if $seen{$name}++;
499 $meta{supported_kinds} = [@{$tag}[1 .. $#$tag]];
500 } elsif ($flags{$name}) {
501 croak "$name must be a single-element tag occurring at most once" unless @$tag == 1 && !$seen{$name}++;
502 $meta{$name} = 1;
503 }
504 }
505  
506 $class->_metadata_tags($meta{group_id}, \%meta, 0);
507 return \%meta;
508 }
509  
510 sub admins_from_event {
511 my ($class, $event) = @_;
512 croak "event must be kind 39001" unless $event->kind == 39001;
513  
514 my %result;
515 my @admins;
516  
517 for my $tag (@{$event->tags}) {
518 if ($tag->[0] eq 'd') {
519 $result{group_id} = $tag->[1];
520 } elsif ($tag->[0] eq 'p') {
521 push @admins, {
522 pubkey => $tag->[1],
523 roles => [@{$tag}[2 .. $#$tag]],
524 };
525 }
526 }
527  
528 $result{admins} = \@admins;
529 return \%result;
530 }
531  
532 sub members_from_event {
533 my ($class, $event) = @_;
534 croak "event must be kind 39002" unless $event->kind == 39002;
535  
536 my %result;
537 my @members;
538  
539 for my $tag (@{$event->tags}) {
540 if ($tag->[0] eq 'd') {
541 $result{group_id} = $tag->[1];
542 } elsif ($tag->[0] eq 'p') {
543 push @members, $tag->[1];
544 }
545 }
546  
547 $result{members} = \@members;
548 return \%result;
549 }
550  
551 sub roles_from_event {
552 my ($class, $event) = @_;
553 croak "event must be kind 39003" unless $event->kind == 39003;
554  
555 my %result;
556 my @roles;
557  
558 for my $tag (@{$event->tags}) {
559 if ($tag->[0] eq 'd') {
560 $result{group_id} = $tag->[1];
561 } elsif ($tag->[0] eq 'role') {
562 push @roles, {
563 name => $tag->[1],
564 description => $tag->[2],
565 };
566 }
567 }
568  
569 $result{roles} = \@roles;
570 return \%result;
571 }
572  
573 sub participants_from_event {
574 my ($class, $event) = @_;
575 croak "event must be kind 39004" unless $event->kind == 39004;
576  
577 my %result;
578 my @participants;
579  
580 for my $tag (@{$event->tags}) {
581 if ($tag->[0] eq 'd') {
582 $result{group_id} = $tag->[1];
583 } elsif ($tag->[0] eq 'participant') {
584 push @participants, $tag->[1];
585 }
586 }
587  
588 $result{participants} = \@participants;
589 return \%result;
590 }
591  
592 sub group_id_from_event {
593 my ($class, $event) = @_;
594 # h tag takes priority (user/mod events); d tag is fallback (metadata events)
595 my $d_val;
596 for my $tag (@{$event->tags}) {
597 return $tag->[1] if $tag->[0] eq 'h';
598 $d_val //= $tag->[1] if $tag->[0] eq 'd';
599 }
600 return $d_val;
601 }
602  
603 1;
604  
605 __END__
« Event.pm ↑ Summary