├── .github
    └── workflows
    │   ├── create-zip-release.yml
    │   ├── lint.yml
    │   ├── phpunit.yml
    │   └── tweet-release.yml
├── .gitignore
├── CHANGES.txt
├── README.md
├── actions
    └── event_manager
    │   ├── attendees
    │       ├── export.php
    │       └── move_to_attendees.php
    │   ├── day
    │       └── edit.php
    │   ├── delete_program_item.php
    │   ├── event
    │       ├── copy.php
    │       ├── deletefile.php
    │       ├── edit.php
    │       ├── mail.php
    │       ├── register.php
    │       ├── resend_confirmation.php
    │       ├── rsvp.php
    │       ├── unsubscribe.php
    │       ├── unsubscribe_confirm.php
    │       └── upload.php
    │   ├── maps
    │       └── data.php
    │   ├── registration
    │       ├── confirm.php
    │       └── pdf.php
    │   └── slot
    │       └── save.php
├── classes
    ├── ColdTrick
    │   └── EventManager
    │   │   ├── Access.php
    │   │   ├── Attendees.php
    │   │   ├── Bootstrap.php
    │   │   ├── Controllers
    │   │       └── Calendar.php
    │   │   ├── Event
    │   │       ├── Day.php
    │   │       └── Slot.php
    │   │   ├── Forms
    │   │       └── EventMail.php
    │   │   ├── GroupToolContainerLogicCheck.php
    │   │   ├── Icons.php
    │   │   ├── Js.php
    │   │   ├── Menus.php
    │   │   ├── Menus
    │   │       ├── Entity.php
    │   │       ├── Filter.php
    │   │       ├── FilterEventAttendees.php
    │   │       └── Site.php
    │   │   ├── MigrateEvents.php
    │   │   ├── Notifications.php
    │   │   ├── Notifications
    │   │       ├── CreateEventEventHandler.php
    │   │       └── CreateEventMailEventHandler.php
    │   │   ├── ObjectPicker.php
    │   │   ├── Search.php
    │   │   ├── Seeder.php
    │   │   ├── Views.php
    │   │   └── Widgets.php
    ├── Event.php
    ├── EventMail.php
    ├── EventRegistration.php
    └── EventRegistrationQuestion.php
├── composer.json
├── composer.lock
├── elgg-plugin.php
├── languages
    ├── de.php
    ├── en.php
    ├── es.php
    ├── fi.php
    ├── fr.php
    ├── gd.php
    ├── ja.php
    └── nl.php
├── lib
    └── functions.php
└── views
    └── default
        ├── event_manager
            ├── addthisevent
            │   ├── button.css
            │   ├── button.mjs
            │   ├── button.php
            │   ├── email.css
            │   ├── email.php
            │   └── settings.js.php
            ├── event
            │   ├── attendees_list.php
            │   ├── files.php
            │   ├── pdf.php
            │   ├── popup.php
            │   ├── registration.php
            │   ├── rsvp.php
            │   ├── sidebar.php
            │   ├── sidebar
            │   │   └── attendees.php
            │   ├── view.php
            │   └── view
            │   │   ├── attendees.php
            │   │   ├── banner.php
            │   │   ├── contact_details.php
            │   │   ├── datetime.php
            │   │   ├── description.php
            │   │   ├── files.php
            │   │   ├── location.php
            │   │   └── registration.php
            ├── forms
            │   └── program
            │   │   ├── day.php
            │   │   └── slot.php
            ├── listing
            │   ├── calendar.mjs.php
            │   ├── calendar.php
            │   ├── elements
            │   │   └── tags.php
            │   ├── list.php
            │   └── map.php
            ├── maps
            │   └── osm
            │   │   ├── location.php
            │   │   ├── location_input.mjs
            │   │   ├── location_input.php
            │   │   ├── onthemap.mjs
            │   │   ├── osm.mjs
            │   │   └── route.php
            ├── program
            │   ├── edit.php
            │   ├── elements
            │   │   ├── day.php
            │   │   └── slot.php
            │   ├── pdf.php
            │   ├── pdf
            │   │   ├── day.php
            │   │   └── slot.php
            │   ├── view.mjs
            │   └── view.php
            ├── registration
            │   ├── completed.php
            │   ├── non_loggedin.php
            │   ├── question.php
            │   └── user_data.php
            └── site.css
        ├── forms
            └── event_manager
            │   ├── event
            │       ├── attendees.mjs
            │       ├── attendees.php
            │       ├── copy.php
            │       ├── edit.mjs
            │       ├── edit.php
            │       ├── edit
            │       │   ├── event_type.php
            │       │   └── region.php
            │       ├── mail.php
            │       ├── module.php
            │       ├── register.mjs
            │       ├── register.php
            │       ├── tabs
            │       │   ├── contact.php
            │       │   ├── general.php
            │       │   ├── location.php
            │       │   ├── location_search.php
            │       │   ├── profile.php
            │       │   ├── questions.php
            │       │   └── registration.php
            │       ├── unsubscribe.php
            │       ├── unsubscribe_confirm.php
            │       └── upload_file.php
            │   ├── registration
            │       └── confirm.php
            │   └── registrationform
            │       └── question.php
        ├── groups
            └── profile
            │   └── module
            │       └── event_manager.php
        ├── icon
            └── object
            │   ├── event.php
            │   └── eventregistration.php
        ├── object
            ├── event.php
            └── eventregistration.php
        ├── plugins
            └── event_manager
            │   ├── settings.mjs
            │   └── settings.php
        ├── resources
            ├── event
            │   ├── add.php
            │   ├── attendees.php
            │   ├── attending.php
            │   ├── edit.php
            │   ├── edit_program.php
            │   ├── live.php
            │   ├── mail.php
            │   ├── owner.php
            │   ├── register.php
            │   ├── unsubscribe
            │   │   ├── confirm.php
            │   │   └── request.php
            │   ├── upcoming.php
            │   ├── upload.php
            │   ├── view.php
            │   └── waitinglist.php
            └── eventregistration
            │   ├── completed.php
            │   ├── confirm.php
            │   └── view.php
        ├── river
            └── event_relationship
            │   └── create.php
        └── widgets
            ├── events
                ├── content.php
                └── edit.php
            └── highlighted_events
                ├── content.php
                └── edit.php


/.github/workflows/create-zip-release.yml:
--------------------------------------------------------------------------------
 1 | name: Create ZIP Release
 2 | 
 3 | on:
 4 |   release:
 5 |     types: [created, edited]
 6 | 
 7 | jobs:
 8 |   build:
 9 |     name: Build release
10 |     uses: ColdTrick/.github/.github/workflows/create-zip-release.yml@master
11 | 


--------------------------------------------------------------------------------
/.github/workflows/lint.yml:
--------------------------------------------------------------------------------
1 | name: Lint checks
2 | 
3 | on: [push, pull_request]
4 | 
5 | jobs:
6 |   lint:
7 |     name: Lint checks
8 |     uses: ColdTrick/.github/.github/workflows/lint.yml@master
9 | 


--------------------------------------------------------------------------------
/.github/workflows/phpunit.yml:
--------------------------------------------------------------------------------
 1 | name: PHPUnit Plugin Tests
 2 | 
 3 | on: [push, pull_request]
 4 | 
 5 | jobs:
 6 |   phpunit:
 7 |     name: Run PHPUnit test suites
 8 |     uses: ColdTrick/.github/.github/workflows/phpunit.yml@master
 9 |     with:
10 |       elgg_major_version: 6
11 | 


--------------------------------------------------------------------------------
/.github/workflows/tweet-release.yml:
--------------------------------------------------------------------------------
 1 | name: Tweet about a new release
 2 | 
 3 | on:
 4 |   release:
 5 |     types: [created]
 6 | 
 7 | jobs:
 8 |   tweet:
 9 |     name: Send a Tweet
10 |     uses: ColdTrick/.github/.github/workflows/tweet-release.yml@master
11 |     secrets: inherit
12 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /vendor/
2 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Event Manager
 2 | =============
 3 | 
 4 | ![Elgg 6.0](https://img.shields.io/badge/Elgg-6.0-green.svg)
 5 | ![Lint Checks](https://github.com/ColdTrick/event_manager/actions/workflows/lint.yml/badge.svg?event=push)
 6 | [![Latest Stable Version](https://poser.pugx.org/coldtrick/event_manager/v/stable.svg)](https://packagist.org/packages/coldtrick/event_manager)
 7 | [![License](https://poser.pugx.org/coldtrick/event_manager/license.svg)](https://packagist.org/packages/coldtrick/event_manager)
 8 | 
 9 | Manage events, from a simple appointment to a multi day event with day programs and subscriptions
10 | 
11 | Features
12 | --------
13 | 
14 | - Create site and group events
15 | - Listing of upcoming events
16 | - Maps integration
17 |  - Show events on a map (using OpenStreetMaps with Leaflet.js)
18 | 
19 | - Create simple or advanced events with
20 |  - Registration forms
21 |  - Configure a multi-day and multi-slot programs
22 |  - Waiting lists
23 |  - Different types of attendance
24 |  - Optionally let logged-out users register
25 |  - Notifications to organizer and attendees
26 |  - Add files to your event
27 |  - Export attendees
28 |  
29 | - RSVP option to confirm attendance to an event
30 | - After RSVP, specify your personal daily program participation
31 | - Receive personal program as PDF
32 | - Add event to your personal calendar software (ical export)
33 | 


--------------------------------------------------------------------------------
/actions/event_manager/attendees/export.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $guid = (int) get_input('guid');
 4 | $rel = get_input('rel', EVENT_MANAGER_RELATION_ATTENDING);
 5 | 
 6 | $event = get_entity($guid);
 7 | if (!$event instanceof \Event || !$event->canEdit()) {
 8 | 	return elgg_error_response(elgg_echo('actionunauthorized'));
 9 | }
10 | 
11 | $rows = elgg_call(ELGG_IGNORE_ACCESS, function() use ($rel, $event) {
12 | 	$rows = [];
13 | 	
14 | 	$attendees = new \ElggBatch('elgg_get_entities', [
15 | 		'relationship' => $rel,
16 | 		'relationship_guid' => $event->guid,
17 | 		'inverse_relationship' => false,
18 | 		'limit' => false,
19 | 	]);
20 | 	
21 | 	foreach ($attendees as $attendee) {
22 | 		$params = [
23 | 			'event' => $event,
24 | 			'attendee' => $attendee,
25 | 			'relationship' => $rel,
26 | 		];
27 | 		
28 | 		$rowdata = elgg_trigger_event_results('export_attendee', 'event', $params, []);
29 | 		if (empty($rowdata)) {
30 | 			continue;
31 | 		}
32 | 		
33 | 		$rows[] = $rowdata;
34 | 	}
35 | 	
36 | 	return $rows;
37 | });
38 | 
39 | if (empty($rows)) {
40 | 	return elgg_error_response(elgg_echo('event_manager:action:attendees:export:no_data'));
41 | }
42 | 
43 | $fh = tmpfile();
44 | 
45 | fputcsv($fh, array_keys($rows[0]), ';');
46 | 
47 | foreach ($rows as $row) {
48 | 	$decoded_rows = array_map(function($row) {
49 | 		return html_entity_decode((string) $row);
50 | 	}, array_values($row));
51 | 	
52 | 	fputcsv($fh, $decoded_rows, ';');
53 | }
54 | 
55 | $contents = '';
56 | rewind($fh);
57 | while (!feof($fh)) {
58 | 	$contents .= fread($fh, 2048);
59 | }
60 | 
61 | fclose($fh);
62 | 
63 | // create export file
64 | header('Content-Type: text/csv');
65 | header('Content-Disposition: Attachment; filename="attendees-' . elgg_get_friendly_title($event->getDisplayName()) . '.csv"');
66 | header('Content-Length: ' . strlen($contents));
67 | header('Pragma: public');
68 | 
69 | echo $contents;
70 | 
71 | exit();
72 | 


--------------------------------------------------------------------------------
/actions/event_manager/attendees/move_to_attendees.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $guid = (int) get_input('guid');
 4 | $user = (int) get_input('user'); // could also be a registration object
 5 | 
 6 | $event = get_entity($guid);
 7 | $object = get_entity($user);
 8 | 
 9 | if (!$event instanceof \Event || !$event->canEdit() || (!$object instanceof \ElggUser && !$object instanceof \EventRegistration)) {
10 | 	return elgg_error_response(elgg_echo('actionunauthorized'));
11 | }
12 | 
13 | // check if object has relation ship that can be moved
14 | $user_relationship = $event->getRelationshipByUser($object->guid);
15 | 
16 | if (!in_array($user_relationship, [EVENT_MANAGER_RELATION_ATTENDING_PENDING, EVENT_MANAGER_RELATION_ATTENDING_WAITINGLIST])) {
17 | 	return elgg_error_response();
18 | }
19 | 
20 | // update pending slots
21 | $slots = $event->getRegisteredSlotsForEntity($object->guid, EVENT_MANAGER_RELATION_SLOT_REGISTRATION_PENDING);
22 | if ($slots) {
23 | 	foreach ($slots as $slot) {
24 | 		$object->removeRelationship($slot->guid, EVENT_MANAGER_RELATION_SLOT_REGISTRATION_PENDING);
25 | 		$object->addRelationship($slot->guid, EVENT_MANAGER_RELATION_SLOT_REGISTRATION);
26 | 	}
27 | }
28 | 
29 | // update waiting slots
30 | $slots = $event->getRegisteredSlotsForEntity($object->guid, EVENT_MANAGER_RELATION_SLOT_REGISTRATION_WAITINGLIST);
31 | if ($slots) {
32 | 	foreach ($slots as $slot) {
33 | 		$object->removeRelationship($slot->guid, EVENT_MANAGER_RELATION_SLOT_REGISTRATION_WAITINGLIST);
34 | 		$object->addRelationship($slot->guid, EVENT_MANAGER_RELATION_SLOT_REGISTRATION);
35 | 	}
36 | }
37 | 
38 | // pending / waitinglist
39 | $event->rsvp(EVENT_MANAGER_RELATION_ATTENDING, $object->guid);
40 | 
41 | return elgg_ok_response('', elgg_echo('event_manager:action:move_to_attendees:success'));
42 | 


--------------------------------------------------------------------------------
/actions/event_manager/day/edit.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $parent_guid = (int) get_input('parent_guid');
 4 | 
 5 | $event = get_entity($parent_guid);
 6 | if (!$event instanceof \Event || !$event->canEdit()) {
 7 | 	return elgg_error_response(elgg_echo('actionunauthorized'));
 8 | }
 9 | 
10 | $guid = (int) get_input('guid');
11 | $title = get_input('title');
12 | $description = get_input('description');
13 | $date = (int) get_input('date');
14 | 
15 | $edit = false;
16 | 
17 | $day = elgg_call(ELGG_IGNORE_ACCESS, function() use ($guid) {
18 | 	// days are unavailable if event is private
19 | 	return get_entity($guid);
20 | });
21 | 
22 | if ($day instanceof \ColdTrick\EventManager\Event\Day) {
23 | 	$edit = true;
24 | } else {
25 | 	// create new
26 | 	$day = new \ColdTrick\EventManager\Event\Day();
27 | }
28 | 
29 | if (empty($day) || empty($date)) {
30 | 	return elgg_error_response(elgg_echo('save:fail'));
31 | }
32 | 
33 | $day->title = $title;
34 | $day->description = $description;
35 | $day->container_guid = $event->guid;
36 | $day->owner_guid = $event->guid;
37 | $day->access_id = $event->access_id;
38 | 
39 | if (!$day->save()) {
40 | 	return elgg_error_response(elgg_echo('save:fail'));
41 | }
42 | 
43 | $day->date = $date;
44 | 
45 | $day->addRelationship($event->guid, 'event_day_relation');
46 | 
47 | $content_title = $day->description;
48 | if (empty($content_title)) {
49 | 	$content_title = event_manager_format_date($day->date);
50 | }
51 | 
52 | if (!$edit) {
53 | 	$title_anchor = elgg_view('output/url', [
54 | 		'href' => "#event_manager_event_view_program-{$day->guid}",
55 | 		'text' => $content_title,
56 | 		'rel' => "day_{$day->guid}",
57 | 		'data-target' => "#event_manager_event_view_program-{$day->guid}",
58 | 		'class' => [
59 | 			'elgg-menu-content',
60 | 		],
61 | 	]);
62 | 	$content_title = elgg_format_element('li', [
63 | 		'data-menu-item' => "event_manager_event_view_program-tab-{$day->guid}",
64 | 		'class' => [
65 | 			"elgg-menu-item-event-manager-event-view-program-tab-{$day->guid}",
66 | 			'elgg-components-tab',
67 | 		],
68 | 	], $title_anchor);
69 | }
70 | 
71 | $content_body = elgg_view('event_manager/program/elements/day', [
72 | 	'entity' => $day,
73 | 	'details_only' => $edit,
74 | ]);
75 | 
76 | if (!$edit) {
77 | 	$content_body = elgg_format_element('div', [
78 | 		'class' => 'elgg-content',
79 | 		'id' => "event_manager_event_view_program-{$day->guid}",
80 | 	], $content_body);
81 | }
82 | 	
83 | $result = [
84 | 	'guid' => $day->guid,
85 | 	'edit' => $edit,
86 | 	'content_title' => $content_title,
87 | 	'content_body' => $content_body,
88 | ];
89 | 
90 | return elgg_ok_response($result);
91 | 


--------------------------------------------------------------------------------
/actions/event_manager/delete_program_item.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Default entity delete action
 4 |  */
 5 | 
 6 | $guid = (int) get_input('guid');
 7 | $entity = elgg_call(ELGG_IGNORE_ACCESS | ELGG_SHOW_DISABLED_ENTITIES | ELGG_SHOW_DELETED_ENTITIES, function() use ($guid) {
 8 | 	return get_entity($guid);
 9 | });
10 | if (!$entity instanceof \ColdTrick\EventManager\Event\Day && !$entity instanceof \ColdTrick\EventManager\Event\Slot) {
11 | 	return elgg_error_response(elgg_echo('entity:delete:item_not_found'));
12 | }
13 | 
14 | if (!$entity->canDelete()) {
15 | 	return elgg_error_response(elgg_echo('entity:delete:permission_denied'));
16 | }
17 | 
18 | // determine what name to show on success
19 | $display_name = $entity->getDisplayName() ?: elgg_echo('entity:delete:item');
20 | 
21 | $type = $entity->getType();
22 | $subtype = $entity->getSubtype();
23 | 
24 | if (!$entity->delete(true, true)) {
25 | 	return elgg_error_response(elgg_echo('entity:delete:fail', [$display_name]));
26 | }
27 | 
28 | $success_keys = [
29 | 	"entity:delete:{$type}:{$subtype}:success",
30 | 	"entity:delete:{$type}:success",
31 | 	'entity:delete:success',
32 | ];
33 | 
34 | $message = '';
35 | if (get_input('show_success', true)) {
36 | 	foreach ($success_keys as $success_key) {
37 | 		if (elgg_language_key_exists($success_key)) {
38 | 			$message = elgg_echo($success_key, [$display_name]);
39 | 			break;
40 | 		}
41 | 	}
42 | }
43 | 
44 | return elgg_ok_response('', $message);
45 | 


--------------------------------------------------------------------------------
/actions/event_manager/event/copy.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | use Elgg\Values;
  4 | 
  5 | $guid = (int) get_input('guid');
  6 | if (empty($guid)) {
  7 | 	return elgg_error_response(elgg_echo('error:missing_data'));
  8 | }
  9 | 
 10 | $old_event = get_entity($guid);
 11 | if (!$old_event instanceof \Event || !$old_event->canEdit()) {
 12 | 	return elgg_error_response(elgg_echo('actionunauthorized'));
 13 | }
 14 | 
 15 | $new_owner_guid = elgg_get_logged_in_user_guid();
 16 | $new_container_guid = $old_event->getContainerGUID();
 17 | if ($old_event->getContainerEntity() instanceof \ElggUser) {
 18 | 	$new_container_guid = elgg_get_logged_in_user_guid();
 19 | }
 20 | 
 21 | $new_event = clone $old_event;
 22 | $new_event->owner_guid = $new_owner_guid;
 23 | $new_event->container_guid = $new_container_guid;
 24 | 
 25 | $new_event->title = get_input('title', elgg_echo('event_manager:entity:copy', [$old_event->title]));
 26 | $new_event->access_id = get_input('access_id', $new_event->access_id);
 27 | 
 28 | $event_start = (int) get_input('event_start');
 29 | if ($event_start) {
 30 | 	$event_start += (int) get_input('start_time');
 31 | 	$new_event->event_start = $event_start;
 32 | }
 33 | 
 34 | $event_end = (int) get_input('event_end');
 35 | if ($event_end) {
 36 | 	$event_end += (int) get_input('end_time');
 37 | 	$new_event->event_end = $event_end;
 38 | }
 39 | 
 40 | unset($new_event->notification_sent_ts);
 41 | 
 42 | $announcement_period = (int) get_input('announcement_period');
 43 | if ($announcement_period < 1) {
 44 | 	$notification_queued_ts = time();
 45 | } else {
 46 | 	$notification_queued_ts = Values::normalizeTime($event_start)->setTime(0, 0, 0)->modify("-{$announcement_period} weeks")->getTimestamp();
 47 | 	if ($notification_queued_ts <= time()) {
 48 | 		$notification_queued_ts = time();
 49 | 	}
 50 | }
 51 | 
 52 | if (!empty($notification_queued_ts)) {
 53 | 	// only set if notifications are not sent
 54 | 	// only set for new events or if previously saved with a notification queued (to differentiate with event with the new notification logic)
 55 | 	$new_event->announcement_period = $announcement_period;
 56 | 	$new_event->notification_queued_ts = $notification_queued_ts;
 57 | } else {
 58 | 	unset($new_event->announcement_period);
 59 | 	unset($new_event->notification_queued_ts);
 60 | }
 61 | 
 62 | // remove entity_view_counter stats
 63 | unset($new_event->entity_view_count);
 64 | 
 65 | if (!$new_event->save()) {
 66 | 	return elgg_error_response(elgg_echo('unknown_error'));
 67 | }
 68 | 
 69 | foreach ($old_event->getEventDays() as $day) {
 70 | 	$new_day = clone $day;
 71 | 	$new_day->container_guid = $new_event->guid;
 72 | 	$new_day->owner_guid = $new_event->guid;
 73 | 	
 74 | 	$new_day->save();
 75 | 	$new_day->addRelationship($new_event->guid, 'event_day_relation');
 76 | 
 77 | 	foreach ($day->getEventSlots() as $slot) {
 78 | 		$new_slot = clone $slot;
 79 | 		$new_slot->container_guid = $new_day->getContainerGUID();
 80 | 		$new_slot->owner_guid = $new_day->getOwnerGUID();
 81 | 		$new_slot->save();
 82 | 		$new_slot->addRelationship($new_day->guid, 'event_day_slot_relation');
 83 | 	}
 84 | }
 85 | 
 86 | foreach ($old_event->getRegistrationFormQuestions() as $question) {
 87 | 	$new_question = clone $question;
 88 | 	$new_question->container_guid = $new_event->guid;
 89 | 	$new_question->owner_guid = $new_event->guid;
 90 | 	$new_question->save();
 91 | 	$new_question->addRelationship($new_event->guid, 'event_registrationquestion_relation');
 92 | }
 93 | 
 94 | // copy all event files
 95 | $dir = new \Elgg\EntityDirLocator($old_event->guid);
 96 | $source = elgg_get_data_path() . $dir;
 97 | if (is_dir($source)) {
 98 | 	$dir = new \Elgg\EntityDirLocator($new_event->guid);
 99 | 	$dest = elgg_get_data_path() . $dir;
100 | 	
101 | 	// create new event data structure bucket
102 | 	mkdir($dest, 0755, true);
103 | 	
104 | 	$iterator = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($source, \RecursiveDirectoryIterator::SKIP_DOTS), \RecursiveIteratorIterator::SELF_FIRST);
105 | 	foreach ($iterator as $item) {
106 | 		if ($item->isDir()) {
107 | 			mkdir($dest . DIRECTORY_SEPARATOR . $iterator->getSubPathName(), 0755, true);
108 | 		} else {
109 | 			copy($item, $dest . DIRECTORY_SEPARATOR . $iterator->getSubPathName());
110 | 		}
111 | 	}
112 | }
113 | 
114 | return elgg_ok_response('', elgg_echo('event_manager:action:event:edit:ok'), $new_event->getURL());
115 | 


--------------------------------------------------------------------------------
/actions/event_manager/event/deletefile.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $guid = (int) get_input('guid');
 4 | $filename = get_input('file', null, false);
 5 | 
 6 | $event = get_entity($guid);
 7 | 
 8 | if (empty($filename) || !($event instanceof \Event) || !$event->canEdit()) {
 9 | 	return elgg_error_response(elgg_echo('event_manager:event:file:notfound:text'));
10 | }
11 | 
12 | $files = $event->getFiles();
13 | 
14 | foreach ($files as $index => $file) {
15 | 	if (strtolower($file->file) == strtolower($filename)) {
16 | 		$fileHandler = new \ElggFile();
17 | 		$fileHandler->owner_guid = $event->guid;
18 | 		$fileHandler->setFilename($file->file);
19 | 		
20 | 		if (!$fileHandler->exists()) {
21 | 			// check old storage location
22 | 			$fileHandler->setFilename("files/{$file->file}");
23 | 		}
24 | 		
25 | 		if ($fileHandler->delete()) {
26 | 			unset($files[$index]);
27 | 		}
28 | 	}
29 | }
30 | 
31 | $files = array_values($files);
32 | 
33 | $event->files = $files ? json_encode($files) : null;
34 | 
35 | return elgg_ok_response();
36 | 


--------------------------------------------------------------------------------
/actions/event_manager/event/mail.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | elgg_make_sticky_form('event_manager/event/mail');
 4 | 
 5 | $guid = (int) get_input('guid');
 6 | $title = get_input('title');
 7 | $description = get_input('description');
 8 | $recipients = (array) get_input('recipients');
 9 | 
10 | $entity = get_entity($guid);
11 | if (!$entity instanceof \Event || !$entity->canEdit()) {
12 | 	return elgg_error_response(elgg_echo('actionunauthorized'));
13 | }
14 | 
15 | if (empty($title) || empty($description) || empty($recipients)) {
16 | 	return elgg_error_response(elgg_echo('error:missing_data'));
17 | }
18 | 
19 | $mail = new \EventMail();
20 | $mail->container_guid = $entity->guid;
21 | 
22 | $mail->title = $title;
23 | $mail->description = $description;
24 | $mail->recipients = $recipients;
25 | 
26 | if (!$mail->save()) {
27 | 	return elgg_error_response(elgg_echo('save:fail'));
28 | }
29 | 
30 | elgg_clear_sticky_form('event_manager/event/mail');
31 | 
32 | return elgg_ok_response('', elgg_echo('event_manager:action:event:mail:success'), $entity->getURL());
33 | 


--------------------------------------------------------------------------------
/actions/event_manager/event/resend_confirmation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $guid = (int) get_input('guid');
 4 | $user = (int) get_input('user'); // could also be a registration object
 5 | 
 6 | $event = get_entity($guid);
 7 | $object = get_entity($user);
 8 | 
 9 | if (!$event instanceof \Event || !$event->canEdit() || (!$object instanceof \ElggUser && !$object instanceof \EventRegistration)) {
10 | 	return elgg_error_response(elgg_echo('actionunauthorized'));
11 | }
12 | 
13 | event_manager_send_registration_validation_email($event, $object);
14 | 
15 | return elgg_ok_response('', elgg_echo('event_manager:action:resend_confirmation:success'));
16 | 


--------------------------------------------------------------------------------
/actions/event_manager/event/rsvp.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $guid = (int) get_input('guid');
 4 | $user_guid = (int) get_input('user', elgg_get_logged_in_user_guid());
 5 | $rel = get_input('type');
 6 | 
 7 | $forward_url = get_input('forward_url', REFERRER);
 8 | $rsvp = null;
 9 | 
10 | if (empty($guid) || empty($user_guid)) {
11 | 	return elgg_error_response(elgg_echo('error:missing_data'));
12 | }
13 | 
14 | $event = get_entity($guid);
15 | $user = get_entity($user_guid);
16 | if (!$event instanceof \Event || (!$user instanceof \ElggUser && !$user instanceof \EventRegistration)) {
17 | 	return elgg_error_response(elgg_echo('error:missing_data'));
18 | }
19 | 
20 | if (!elgg_is_logged_in()) {
21 | 	$code = get_input('code');
22 | 	if (!event_manager_validate_registration_validation_code($guid, $user_guid, $code)) {
23 | 		return elgg_error_response(elgg_echo('event_manager:registration:confirm:error:code'));
24 | 	}
25 | } elseif (!$user->canEdit() && !$event->canEdit()) {
26 | 	return elgg_echo('actionunauthorized');
27 | }
28 | 
29 | if (empty($rel)) {
30 | 	return elgg_error_response(elgg_echo('error:missing_data'));
31 | }
32 | 
33 | if ($rel == EVENT_MANAGER_RELATION_ATTENDING) {
34 | 	if ($event->hasEventSpotsLeft() && $event->hasSlotSpotsLeft()) {
35 | 		if ($event->registration_needed && $event->hasRegistrationForm()) {
36 | 			return elgg_redirect_response(elgg_generate_url('default:object:event:register', [
37 | 				'guid' => $guid,
38 | 			]));
39 | 		} else {
40 | 			$rsvp = $event->rsvp($rel, $user_guid);
41 | 		}
42 | 	} else {
43 | 		if ($event->waiting_list_enabled) {
44 | 			$rel = EVENT_MANAGER_RELATION_ATTENDING_WAITINGLIST;
45 | 			if ($event->openForRegistration()) {
46 | 				if ($event->registration_needed && $event->hasRegistrationForm()) {
47 | 					return elgg_redirect_response(elgg_generate_url('collection:object:event:waitinglist', ['guid' => $guid]));
48 | 				} else {
49 | 					$rsvp = $event->rsvp($rel, $user_guid);
50 | 				}
51 | 			} else {
52 | 				return elgg_error_response(elgg_echo('event_manager:event:rsvp:registration_ended'));
53 | 			}
54 | 		} else {
55 | 			return elgg_error_response(elgg_echo('event_manager:event:rsvp:nospotsleft'));
56 | 		}
57 | 	}
58 | } else {
59 | 	if ($event->$rel || ($rel == EVENT_MANAGER_RELATION_UNDO)) {
60 | 		$rsvp = $event->rsvp($rel, $user_guid);
61 | 	} else {
62 | 		return elgg_error_response(elgg_echo('event_manager:event:relationship:message:unavailable_relation'));
63 | 	}
64 | }
65 | 
66 | if (!$rsvp) {
67 | 	return elgg_error_response(elgg_echo('event_manager:event:relationship:message:error'));
68 | }
69 | 
70 | return elgg_ok_response('', elgg_echo("event_manager:event:relationship:message:{$rel}"), $forward_url);
71 | 


--------------------------------------------------------------------------------
/actions/event_manager/event/unsubscribe.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | elgg_make_sticky_form('event_unsubscribe');
 4 | 
 5 | $guid = (int) get_input('guid');
 6 | $email = (string) get_input('email');
 7 | 
 8 | $entity = get_entity($guid);
 9 | if (!$entity instanceof \Event) {
10 | 	return elgg_echo('actionunauthorized');
11 | }
12 | 
13 | if (!elgg_is_valid_email($email)) {
14 | 	return elgg_error_response(elgg_echo('registration:notemail'));
15 | }
16 | 			
17 | // try to find a registration
18 | $registrations = elgg_get_entities([
19 | 	'type' => 'object',
20 | 	'subtype' => \EventRegistration::SUBTYPE,
21 | 	'owner_guid' => $entity->guid,
22 | 	'limit' => 1,
23 | 	'metadata_name_value_pairs' => [
24 | 		'name' => 'email',
25 | 		'value' => $email,
26 | 		'case_sensitive' => false,
27 | 	],
28 | ]);
29 | 
30 | if (empty($registrations)) {
31 | 	return elgg_error_response(elgg_echo('event_manager:action:unsubscribe:error:no_registration'));
32 | }
33 | 
34 | $registration = $registrations[0];
35 | 
36 | $unsubscribe_link = elgg_generate_url('default:object:event:unsubscribe:confirm', [
37 | 	'guid' => $registration->guid,
38 | 	'code' => event_manager_create_unsubscribe_code($registration, $entity),
39 | ]);
40 | 
41 | // make a message with further instructions
42 | $subject = elgg_echo('event_manager:unsubscribe:confirm:subject', [$entity->getDisplayName()]);
43 | $message = elgg_echo('event_manager:unsubscribe:confirm:message', [
44 | 	$entity->getDisplayName(),
45 | 	$entity->getURL(),
46 | 	$unsubscribe_link,
47 | ]);
48 | 
49 | $email_sent = elgg_send_email(\Elgg\Email::factory([
50 | 	'to' => $registration,
51 | 	'subject' => $subject,
52 | 	'body' => $message,
53 | ]));
54 | 
55 | if (!$email_sent) {
56 | 	return elgg_error_response(elgg_echo('event_manager:action:unsubscribe:error:mail'));
57 | }
58 | 
59 | elgg_clear_sticky_form('event_unsubscribe');
60 | 
61 | return elgg_ok_response('', elgg_echo('event_manager:action:unsubscribe:success'), $entity->getURL());
62 | 


--------------------------------------------------------------------------------
/actions/event_manager/event/unsubscribe_confirm.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event_guid = (int) get_input('event');
 4 | $registration_guid = (int) get_input('registration');
 5 | $code = get_input('code');
 6 | 
 7 | $event = get_entity($event_guid);
 8 | $registration = get_entity($registration_guid);
 9 | if (!$event instanceof \Event || !$registration instanceof \EventRegistration) {
10 | 	return elgg_echo('actionunauthorized');
11 | }
12 | 
13 | $verify_code = event_manager_create_unsubscribe_code($registration, $event);
14 | 
15 | if ($code !== $verify_code) {
16 | 	return elgg_error_response(elgg_echo('event_manager:unsubscribe_confirm:error:code'));
17 | }
18 | 
19 | if (!$event->rsvp(EVENT_MANAGER_RELATION_UNDO, $registration->guid)) {
20 | 	return elgg_error_response(elgg_echo('event_manager:action:unsubscribe_confirm:error'));
21 | }
22 | 
23 | return elgg_ok_response('', elgg_echo('event_manager:action:unsubscribe_confirm:success'), $event->getURL());
24 | 


--------------------------------------------------------------------------------
/actions/event_manager/event/upload.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $guid = (int) get_input('guid');
 4 | $title = get_input('title');
 5 | 
 6 | $event = get_entity($guid);
 7 | if (!$event instanceof \Event || !$event->canEdit()) {
 8 | 	return elgg_error_response(elgg_echo('actionunauthorized'));
 9 | }
10 | 
11 | if (empty($title)) {
12 | 	return elgg_error_response(elgg_echo('event_manager:action:event:edit:error_fields'));
13 | }
14 | 
15 | // check if upload attempted and failed
16 | $uploaded_file = elgg_get_uploaded_file('file', false);
17 | if ($uploaded_file && !$uploaded_file->isValid()) {
18 | 	$error = elgg_get_friendly_upload_error($uploaded_file->getError());
19 | 	return elgg_error_response($error);
20 | }
21 | 
22 | $filesArray = $event->getFiles();
23 | 
24 | $file = new \ElggFile();
25 | $file->owner_guid = $event->guid;
26 | $file->acceptUploadedFile($uploaded_file);
27 | 
28 | $filesArray[] = [
29 | 	'title' => $title,
30 | 	'file' => $file->getFilename(),
31 | 	'mime' => $file->getMimeType(),
32 | 	'time_uploaded' => time(),
33 | 	'uploader' => elgg_get_logged_in_user_guid(),
34 | ];
35 | 
36 | $event->files = json_encode(array_values($filesArray));
37 | 
38 | return elgg_ok_response('', elgg_echo('event_manager:action:event:edit:ok'));
39 | 


--------------------------------------------------------------------------------
/actions/event_manager/maps/data.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | use Elgg\Database\QueryBuilder;
  4 | use Elgg\Database\Clauses\WhereClause;
  5 | 
  6 | $latitude = get_input('latitude');
  7 | $longitude = get_input('longitude');
  8 | $lat_distance = get_input('distance_latitude');
  9 | $long_distance = get_input('distance_longitude');
 10 | $guid = (int) get_input('guid');
 11 | $resource = get_input('resource');
 12 | $tag = get_input('tag');
 13 | 
 14 | if (!isset($latitude) || !isset($longitude) || !isset($lat_distance) || !isset($long_distance)) {
 15 | 	return [];
 16 | }
 17 | 
 18 | $entity = get_entity($guid);
 19 | 
 20 | $latitude = (float) $latitude;
 21 | $longitude = (float) $longitude;
 22 | $lat_distance = (float) $lat_distance;
 23 | $long_distance = (float) $long_distance;
 24 | 	
 25 | $lat_min = $latitude - $lat_distance;
 26 | $lat_max = $latitude + $lat_distance;
 27 | $long_min = $longitude - $long_distance;
 28 | $long_max = $longitude + $long_distance;
 29 | 
 30 | $options = [
 31 | 	'type' => 'object',
 32 | 	'subtype' => \Event::SUBTYPE,
 33 | 	'limit' => 50,
 34 | 	'container_guid' => ($entity instanceof \ElggGroup) ? $entity->guid : ELGG_ENTITIES_ANY_VALUE,
 35 | 	'wheres' => [
 36 | 		function (QueryBuilder $qb, $main_alias) use ($lat_min, $lat_max, $long_min, $long_max) {
 37 | 			
 38 | 			// cannot use between helper because of casting of values
 39 | 			$lat_alias = $qb->joinMetadataTable($main_alias, 'guid', 'geo:lat');
 40 | 			$long_alias = $qb->joinMetadataTable($main_alias, 'guid', 'geo:long');
 41 | 			
 42 | 			return $qb->merge([
 43 | 				(new WhereClause("{$lat_alias}.value >= {$lat_min}"))->prepare($qb, $main_alias),
 44 | 				(new WhereClause("{$lat_alias}.value <= {$lat_max}"))->prepare($qb, $main_alias),
 45 | 				(new WhereClause("{$long_alias}.value >= {$long_min}"))->prepare($qb, $main_alias),
 46 | 				(new WhereClause("{$long_alias}.value <= {$long_max}"))->prepare($qb, $main_alias),
 47 | 			]);
 48 | 		}
 49 | 	],
 50 | 	'metadata_name_value_pairs' => [
 51 | 		'upcoming' => [
 52 | 			'name' => 'event_start',
 53 | 			'value' => time(),
 54 | 			'operand' => '>=',
 55 | 		],
 56 | 	],
 57 | 	'batch' => true,
 58 | ];
 59 | 
 60 | // resource specific options
 61 | switch ($resource) {
 62 | 	case 'live':
 63 | 		unset($options['metadata_name_value_pairs']['upcoming']);
 64 | 		
 65 | 		$options['metadata_name_value_pairs'][] = [
 66 | 			'name' => 'event_start',
 67 | 			'value' => time(),
 68 | 			'operand' => '<=',
 69 | 		];
 70 | 		$options['metadata_name_value_pairs'][] = [
 71 | 			'name' => 'event_end',
 72 | 			'value' => time(),
 73 | 			'operand' => '>=',
 74 | 		];
 75 | 		break;
 76 | 	case 'owner':
 77 | 		if (!$entity instanceof \ElggUser) {
 78 | 			return elgg_error_response();
 79 | 		}
 80 | 		
 81 | 		unset($options['metadata_name_value_pairs']['upcoming']);
 82 | 		
 83 | 		$options['owner_guid'] = $entity->guid;
 84 | 		break;
 85 | 	case 'attending':
 86 | 		if (!$entity instanceof \ElggUser) {
 87 | 			return elgg_error_response();
 88 | 		}
 89 | 		
 90 | 		$options['relationship'] = EVENT_MANAGER_RELATION_ATTENDING;
 91 | 		$options['relationship_guid'] = $entity->guid;
 92 | 		$options['inverse_relationship'] = true;
 93 | 		break;
 94 | }
 95 | 
 96 | if (!empty($tag)) {
 97 | 	$options['metadata_name_value_pairs'][] = [
 98 | 		'name' => 'tags',
 99 | 		'value' => $tag,
100 | 		'case_sensitive' => false,
101 | 	];
102 | }
103 | 
104 | // let others extend this
105 | $params = [
106 | 	'resource' => $resource,
107 | 	'guid' => $guid,
108 | 	'latitude' => $latitude,
109 | 	'longitude' => $longitude,
110 | 	'distance_latitude' => $lat_distance,
111 | 	'distance_longitude' => $long_distance,
112 | ];
113 | $options = elgg_trigger_event_results('maps_data:options', 'event_manager', $params, $options);
114 | 
115 | // fetch data
116 | $entities = elgg_get_entities($options);
117 | 
118 | $result = [];
119 | foreach ($entities as $event) {
120 | 	$result['markers'][] = [
121 | 		'guid' => $event->guid,
122 | 		'lat' => $event->getLatitude(),
123 | 		'lng' => $event->getLongitude(),
124 | 		'title' => $event->title,
125 | 		'has_relation' => $event->getRelationshipByUser(),
126 | 		'iscreator' => (($event->getOwnerGUID() == elgg_get_logged_in_user_guid()) ? 'owner' : null)
127 | 	];
128 | }
129 | 
130 | return elgg_ok_response($result);
131 | 


--------------------------------------------------------------------------------
/actions/event_manager/registration/confirm.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event_guid = (int) get_input('event_guid');
 4 | $user_guid = (int) get_input('user_guid');
 5 | $code = get_input('code');
 6 | 
 7 | $event = get_entity($event_guid);
 8 | $user = get_entity($user_guid); // can also be a registration object
 9 | if (!$event instanceof \Event || (!$user instanceof \ElggUser && !$user instanceof \EventRegistration)) {
10 | 	return elgg_echo('actionunauthorized');
11 | }
12 | 
13 | // is the code valid
14 | if (!event_manager_validate_registration_validation_code($event_guid, $user_guid, $code)) {
15 | 	return elgg_error_response(elgg_echo('event_manager:registration:confirm:error:code'));
16 | }
17 | 
18 | if (!$event->openForRegistration()) {
19 | 	return elgg_error_response(elgg_echo('event_manager:event:rsvp:registration_ended'), $event->getURL());
20 | }
21 | 
22 | // check if we can become attending or should be on the waitinglist
23 | $relation = EVENT_MANAGER_RELATION_ATTENDING;
24 | $slot_relation = EVENT_MANAGER_RELATION_SLOT_REGISTRATION;
25 | 
26 | if (!$event->hasEventSpotsLeft() || !$event->hasSlotSpotsLeft()) {
27 | 	if ($event->waiting_list_enabled) {
28 | 		$relation = EVENT_MANAGER_RELATION_ATTENDING_WAITINGLIST;
29 | 		$slot_relation = EVENT_MANAGER_RELATION_SLOT_REGISTRATION_WAITINGLIST;
30 | 	} else {
31 | 		return elgg_error_response(elgg_echo('event_manager:event:rsvp:nospotsleft'), $event->getURL());
32 | 	}
33 | }
34 | 
35 | // update all slots from pending to attending/waiting
36 | $slots = $event->getRegisteredSlotsForEntity($user->guid, EVENT_MANAGER_RELATION_SLOT_REGISTRATION_PENDING);
37 | if ($slots) {
38 | 	foreach ($slots as $slot) {
39 | 		$user->removeRelationship($slot->guid, EVENT_MANAGER_RELATION_SLOT_REGISTRATION_PENDING);
40 | 		$user->addRelationship($slot->guid, $slot_relation);
41 | 	}
42 | }
43 | 
44 | // update event relationship to attending/waiting
45 | $event->rsvp($relation, $user->guid);
46 | 
47 | return elgg_ok_response('', elgg_echo("event_manager:event:relationship:message:{$relation}"), $event->getURL());
48 | 


--------------------------------------------------------------------------------
/actions/event_manager/registration/pdf.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Dompdf\Dompdf;
 4 | 
 5 | $key = get_input('k');
 6 | $guid = (int) get_input('guid');
 7 | $user_guid = (int) get_input('u_g', elgg_get_logged_in_user_guid());
 8 | $event = null;
 9 | 
10 | $entity = get_entity($guid);
11 | if ($entity instanceof \Event) {
12 | 	$event = $entity;
13 | }
14 | 
15 | if (!$event || empty($key)) {
16 | 	return elgg_redirect_response(elgg_generate_url('default:object:event'));
17 | }
18 | 
19 | $tempKey = elgg_build_hmac([$event->time_created, $user_guid])->getToken();
20 | 
21 | $entity = get_entity($user_guid);
22 | if (empty($entity) || ($tempKey !== $key)) {
23 | 	return elgg_redirect_response(elgg_generate_url('default:object:event'));
24 | }
25 | 
26 | $html = elgg_view_title(elgg_echo('event_manager:registration:yourregistration'));
27 | 
28 | $html .= elgg_view('event_manager/event/pdf', ['entity' => $event]);
29 | 
30 | $html .= elgg_call(ELGG_IGNORE_ACCESS, function () use ($event, $entity) {
31 | 	$output = elgg_view('event_manager/registration/user_data', [
32 | 		'event' => $event,
33 | 		'entity' => $entity,
34 | 		'show_title' => true,
35 | 	]);
36 | 	
37 | 	if ($event->with_program) {
38 | 		$output .= elgg_view_module('main', '', elgg_view('event_manager/program/pdf', ['entity' => $event, 'user_guid' => $entity->guid]));
39 | 	}
40 | 	
41 | 	return $output;
42 | });
43 | 
44 | $dompdf = new Dompdf(['enable_remote' => true]);
45 | $dompdf->setPaper('A4');
46 | $dompdf->loadHtml($html);
47 | $dompdf->render();
48 | $dompdf->stream('registration.pdf');
49 | 
50 | exit;
51 | 


--------------------------------------------------------------------------------
/actions/event_manager/slot/save.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $parent_guid = (int) get_input('parent_guid');
 4 | 
 5 | $day = elgg_call(ELGG_IGNORE_ACCESS, function() use ($parent_guid) {
 6 | 	// days are unavailable if event is private
 7 | 	return get_entity($parent_guid);
 8 | });
 9 | 
10 | if (!$day instanceof \ColdTrick\EventManager\Event\Day) {
11 | 	return elgg_error_response(elgg_echo('event_manager:action:slot:day_not_found'));
12 | }
13 | 
14 | if (!$day->canEdit()) {
15 | 	return elgg_error_response(elgg_echo('actionunauthorized'));
16 | }
17 | 
18 | $edit = false;
19 | 
20 | $guid = (int) get_input('guid');
21 | $title = get_input('title');
22 | $description = get_input('description');
23 | 
24 | $start_time_ts = (int) get_input('start_time');
25 | 
26 | $minutes = $start_time_ts % 3600;
27 | $hours = $start_time_ts - $minutes;
28 | 
29 | // special handling of time for BC reasons
30 | $start_time = mktime($hours / 3600, $minutes / 60, 1, 0, 0, 0);
31 | 
32 | $end_time_ts = (int) get_input('end_time');
33 | $minutes = $end_time_ts % 3600;
34 | $hours = $end_time_ts - $minutes;
35 | $end_time = mktime($hours / 3600, $minutes / 60, 1, 0, 0, 0);
36 | 
37 | $location = get_input('location');
38 | $max_attendees = (int) get_input('max_attendees');
39 | 
40 | $slot_set = get_input('slot_set');
41 | 
42 | if (empty($title) || empty($start_time) || empty($end_time)) {
43 | 	return elgg_error_response(elgg_echo('event_manager:action:slot:missing_fields'));
44 | }
45 | 
46 | if ($guid) {
47 | 	// edit existing
48 | 	$slot = elgg_call(ELGG_IGNORE_ACCESS, function() use ($guid) {
49 | 		// slots are unavailable if event is private
50 | 		return get_entity($guid);
51 | 	});
52 | 
53 | 	if (!$slot instanceof \ColdTrick\EventManager\Event\Slot) {
54 | 		return elgg_error_response(elgg_echo('event_manager:action:slot:not_found'));
55 | 	}
56 | 
57 | 	$edit = true;
58 | } else {
59 | 	// create new
60 | 	$slot = new \ColdTrick\EventManager\Event\Slot();
61 | }
62 | 
63 | $slot->title = $title;
64 | $slot->description = $description;
65 | $slot->container_guid = $day->container_guid;
66 | $slot->owner_guid = $day->owner_guid;
67 | $slot->access_id = $day->access_id;
68 | $slot->start_time = $start_time;
69 | $slot->end_time = $end_time;
70 | $slot->location = $location;
71 | $slot->max_attendees = $max_attendees ?: null;
72 | 
73 | if (!$slot->save()) {
74 | 	return elgg_error_response(elgg_echo('event_manager:action:slot:cannot_save'));
75 | }
76 | 
77 | if (!empty($slot_set)) {
78 | 	$slot->slot_set = $slot_set;
79 | }
80 | 
81 | if (!$edit) {
82 | 	$slot->addRelationship($day->guid, 'event_day_slot_relation');
83 | }
84 | 
85 | $result = [
86 | 	'edit' => $edit,
87 | 	'guid' => $slot->guid,
88 | 	'parent_guid' => $parent_guid,
89 | 	'content' => elgg_view('event_manager/program/elements/slot', ['entity' => $slot]),
90 | ];
91 | 
92 | return elgg_ok_response($result, elgg_echo('event_manager:action:slot:saved'));
93 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/Access.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ColdTrick\EventManager;
 4 | 
 5 | /**
 6 |  * Access related callbacks
 7 |  */
 8 | class Access {
 9 | 	
10 | 	/**
11 | 	 * After the event is updated in the database make sure the owned entities have the same access_id
12 | 	 *
13 | 	 * @param \Elgg\Event $event 'update:after', 'object'
14 | 	 *
15 | 	 * @return void
16 | 	 */
17 | 	public static function updateEvent(\Elgg\Event $event): void {
18 | 		$entity = $event->getObject();
19 | 		if (!$entity instanceof \Event) {
20 | 			return;
21 | 		}
22 | 		
23 | 		$org_attributes = $entity->getOriginalAttributes();
24 | 		if (elgg_extract('access_id', $org_attributes) === null) {
25 | 			// access wasn't updated
26 | 			return;
27 | 		}
28 | 		
29 | 		elgg_call(ELGG_IGNORE_ACCESS, function() use ($entity) {
30 | 			$days = $entity->getEventDays();
31 | 			if (!empty($days)) {
32 | 				foreach ($days as $day) {
33 | 					$day->access_id = $entity->access_id;
34 | 					$day->save();
35 | 				
36 | 					$slots = $day->getEventSlots();
37 | 					if (empty($slots)) {
38 | 						continue;
39 | 					}
40 | 				
41 | 					foreach ($slots as $slot) {
42 | 						$slot->access_id = $entity->access_id;
43 | 						$slot->save();
44 | 					}
45 | 				}
46 | 			}
47 | 			
48 | 			$questions = $entity->getRegistrationFormQuestions();
49 | 			if (!empty($questions)) {
50 | 				foreach ($questions as $question) {
51 | 					$question->access_id = $entity->access_id;
52 | 					$question->save();
53 | 				}
54 | 			}
55 | 		});
56 | 	}
57 | 	
58 | 	/**
59 | 	 * Checks if plugin setting allows users to write to a container
60 | 	 *
61 | 	 * @param \Elgg\Event $elgg_event 'container_logic_check', 'object'
62 | 	 *
63 | 	 * @return void|false
64 | 	 */
65 | 	public static function containerLogicCheck(\Elgg\Event $elgg_event) {
66 | 		if ($elgg_event->getParam('subtype') !== 'event') {
67 | 			return;
68 | 		}
69 | 		
70 | 		$container = $elgg_event->getParam('container');
71 | 		if ($container instanceof \ElggGroup) {
72 | 			$who_create_group_events = elgg_get_plugin_setting('who_create_group_events', 'event_manager'); // group_admin, members
73 | 			if (empty($who_create_group_events)) {
74 | 				// no one can create
75 | 				return false;
76 | 			}
77 | 			
78 | 			$user = $elgg_event->getUserParam();
79 | 			$user_guid = $user instanceof \ElggUser ? $user->guid : 0;
80 | 			if ($who_create_group_events === 'group_admin' && !$container->canEdit($user_guid)) {
81 | 				return false;
82 | 			}
83 | 			
84 | 			// in other group case let regular checks take place
85 | 		} else {
86 | 			$who_create_site_events = elgg_get_plugin_setting('who_create_site_events', 'event_manager');
87 | 			if ($who_create_site_events === 'admin_only' && !elgg_is_admin_logged_in()) {
88 | 				return false;
89 | 			}
90 | 		}
91 | 	}
92 | }
93 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/Attendees.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ColdTrick\EventManager;
  4 | 
  5 | /**
  6 |  * Attendees related callbacks
  7 |  */
  8 | class Attendees {
  9 | 	
 10 | 	/**
 11 | 	 * Exports base attributes for event attendees
 12 | 	 *
 13 | 	 * @param \Elgg\Event $elgg_event 'export_attendee', 'event'
 14 | 	 *
 15 | 	 * @return array
 16 | 	 */
 17 | 	public static function exportBaseAttributes(\Elgg\Event $elgg_event): array {
 18 | 		
 19 | 		$attendee = $elgg_event->getParam('attendee');
 20 | 		$event = $elgg_event->getParam('event');
 21 | 		$rel = $elgg_event->getParam('relationship');
 22 | 		
 23 | 		$base_attributes = [
 24 | 			'guid' => $attendee->guid,
 25 | 			elgg_echo('name') => $attendee->getDisplayName(),
 26 | 			elgg_echo('email') => $attendee->email,
 27 | 			elgg_echo('username') => $attendee->username,
 28 | 		];
 29 | 		
 30 | 		$relation = $event->getRelationship($attendee->guid, $rel);
 31 | 		if ($relation instanceof \ElggRelationship) {
 32 | 			$base_attributes['registration date'] = date('d-m-Y H:i:s', $relation->time_created);
 33 | 		}
 34 | 		
 35 | 		return array_merge((array) $elgg_event->getValue(), $base_attributes);
 36 | 	}
 37 | 	
 38 | 	/**
 39 | 	 * Exports questiondata for event attendees
 40 | 	 *
 41 | 	 * @param \Elgg\Event $elgg_event 'export_attendee', 'event'
 42 | 	 *
 43 | 	 * @return null|array
 44 | 	 */
 45 | 	public static function exportQuestionData(\Elgg\Event $elgg_event): ?array {
 46 | 		
 47 | 		$attendee = $elgg_event->getParam('attendee');
 48 | 		$event = $elgg_event->getParam('event');
 49 | 		
 50 | 		if (!$event->registration_needed) {
 51 | 			return null;
 52 | 		}
 53 | 		
 54 | 		$questions = $event->getRegistrationFormQuestions();
 55 | 		if (empty($questions)) {
 56 | 			return null;
 57 | 		}
 58 | 		
 59 | 		$question_data = [];
 60 | 		foreach ($questions as $question) {
 61 | 			$value = $question->getAnswerFromUser($attendee->guid)?->value;
 62 | 			
 63 | 			$question_data[$question->getDisplayName()] = $value;
 64 | 		}
 65 | 			
 66 | 		return array_merge((array) $elgg_event->getValue(), $question_data);
 67 | 	}
 68 | 	
 69 | 	/**
 70 | 	 * Exports programchoices for event attendees
 71 | 	 *
 72 | 	 * @param \Elgg\Event $elgg_event 'export_attendee', 'event'
 73 | 	 *
 74 | 	 * @return null|array
 75 | 	 */
 76 | 	public static function exportProgramData(\Elgg\Event $elgg_event): ?array {
 77 | 		
 78 | 		$attendee = $elgg_event->getParam('attendee');
 79 | 		$event = $elgg_event->getParam('event');
 80 | 		
 81 | 		if (!$event->with_program) {
 82 | 			return null;
 83 | 		}
 84 | 		
 85 | 		$days = $event->getEventDays();
 86 | 		if (empty($days)) {
 87 | 			return null;
 88 | 		}
 89 | 		
 90 | 		$program_data = [];
 91 | 		foreach ($days as $day) {
 92 | 			$slots = $day->getEventSlots();
 93 | 			if (empty($slots)) {
 94 | 				continue;
 95 | 			}
 96 | 			
 97 | 			$date = event_manager_format_date($day->date);
 98 | 			
 99 | 			foreach ($slots as $slot) {
100 | 				$start = date('H:i', $slot->start_time);
101 | 				$end = date('H:i', $slot->end_time);
102 | 				
103 | 				$key = "Event activity: '{$slot->getDisplayName()}' $date ($start - $end)";
104 | 				
105 | 				$count = $slot->getEntitiesFromRelationship([
106 | 					'guid' => $attendee->guid,
107 | 					'relationship' => EVENT_MANAGER_RELATION_SLOT_REGISTRATION,
108 | 					'inverse_relationship' => true,
109 | 					'count' => true,
110 | 				]);
111 | 				
112 | 				$value = $count ? 'V' : '';
113 | 			
114 | 				$program_data[$key] = $value;
115 | 			}
116 | 		}
117 | 				
118 | 		return array_merge((array) $elgg_event->getValue(), $program_data);
119 | 	}
120 | }
121 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/Bootstrap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ColdTrick\EventManager;
 4 | 
 5 | use Elgg\DefaultPluginBootstrap;
 6 | 
 7 | /**
 8 |  * Plugin bootstrap
 9 |  */
10 | class Bootstrap extends DefaultPluginBootstrap {
11 | 	
12 | 	/**
13 | 	 * {@inheritdoc}
14 | 	 */
15 | 	public function init() {
16 | 	
17 | 		// add group tool option
18 | 		if (elgg_get_plugin_setting('who_create_group_events', 'event_manager')) {
19 | 			elgg()->group_tools->register('event_manager');
20 | 		}
21 | 				
22 | 		if (elgg_is_active_plugin('entity_tools')) {
23 | 			elgg_register_event_handler('supported_types', 'entity_tools', '\ColdTrick\EventManager\MigrateEvents::supportedSubtypes');
24 | 		}
25 | 		
26 | 		// leafletjs
27 | 		elgg_register_esm('leafletjs', 'https://unpkg.com/leaflet@1.9.4/dist/leaflet.js');
28 | 		elgg_register_external_file('css', 'leafletjs', 'https://unpkg.com/leaflet@1.9.4/dist/leaflet.css', 'head');
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/Controllers/Calendar.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ColdTrick\EventManager\Controllers;
  4 | 
  5 | use Elgg\Exceptions\Http\EntityNotFoundException;
  6 | use Elgg\Http\ResponseBuilder;
  7 | use Elgg\Request;
  8 | 
  9 | /**
 10 |  * Controller to handle /event_manager/calendar requests
 11 |  */
 12 | class Calendar {
 13 | 	
 14 | 	/**
 15 | 	 * Respond to a request
 16 | 	 *
 17 | 	 * @param Request $request the HTTP request
 18 | 	 *
 19 | 	 * @return ResponseBuilder
 20 | 	 * @throws EntityNotFoundException
 21 | 	 */
 22 | 	public function __invoke(Request $request) {
 23 | 		$events_options = [
 24 | 			'type' => 'object',
 25 | 			'subtype' => \Event::SUBTYPE,
 26 | 			'limit' => 999, // not wise to leave unlimited
 27 | 			'batch' => true,
 28 | 			'metadata_name_value_pairs' => [],
 29 | 		];
 30 | 		
 31 | 		$start = get_input('start');
 32 | 		$end = get_input('end');
 33 | 		$guid = (int) get_input('guid');
 34 | 		$resource = get_input('resource');
 35 | 		$tag = get_input('tag');
 36 | 		
 37 | 		if (empty($start) && empty($end)) {
 38 | 			return elgg_ok_response(json_encode([]));
 39 | 		}
 40 | 		
 41 | 		if (!empty($start)) {
 42 | 			$events_options['metadata_name_value_pairs'][] = [
 43 | 				'name' => 'event_end',
 44 | 				'value' => strtotime($start),
 45 | 				'operand' => '>='
 46 | 			];
 47 | 		}
 48 | 		
 49 | 		if (!empty($end)) {
 50 | 			$events_options['metadata_name_value_pairs'][] = [
 51 | 				'name' => 'event_start',
 52 | 				'value' => strtotime($end),
 53 | 				'operand' => '<='
 54 | 			];
 55 | 		}
 56 | 		
 57 | 		if (!empty($tag)) {
 58 | 			$events_options['metadata_name_value_pairs'][] = [
 59 | 				'name' => 'tags',
 60 | 				'value' => $tag,
 61 | 				'case_sensitive' => false,
 62 | 			];
 63 | 		}
 64 | 		
 65 | 		$entity = get_entity($guid);
 66 | 		if ($entity instanceof \ElggGroup) {
 67 | 			$events_options['container_guid'] = $entity->guid;
 68 | 		}
 69 | 		
 70 | 		switch ($resource) {
 71 | 			case 'owner':
 72 | 				if (!$entity instanceof \ElggUser) {
 73 | 					return elgg_ok_response(json_encode([]));
 74 | 				}
 75 | 				
 76 | 				$events_options['owner_guid'] = $entity->guid;
 77 | 				break;
 78 | 			case 'attending':
 79 | 				if (!$entity instanceof \ElggUser) {
 80 | 					return elgg_ok_response(json_encode([]));
 81 | 				}
 82 | 				
 83 | 				$events_options['relationship'] = EVENT_MANAGER_RELATION_ATTENDING;
 84 | 				$events_options['relationship_guid'] = $entity->guid;
 85 | 				$events_options['inverse_relationship'] = true;
 86 | 				break;
 87 | 		}
 88 | 		
 89 | 		// let others extend this
 90 | 		$params = [
 91 | 			'resource' => $resource,
 92 | 			'guid' => $guid,
 93 | 			'start' => $start,
 94 | 			'end' => $end,
 95 | 		];
 96 | 		$events_options = elgg_trigger_event_results('calendar_data:options', 'event_manager', $params, $events_options);
 97 | 		
 98 | 		// fetch data
 99 | 		$events = elgg_get_entities($events_options);
100 | 		
101 | 		$result = [];
102 | 		
103 | 		/* @var $event \Event */
104 | 		foreach ($events as $event) {
105 | 			$start = $event->getStartDate();
106 | 			$end = $event->getEndDate('c');
107 | 			
108 | 			$all_day = $event->isMultiDayEvent();
109 | 			if ($all_day) {
110 | 				// needed for fullcalendar behaviour of allday events
111 | 				$end = date('c', strtotime($end . ' +1 day'));
112 | 			}
113 | 			
114 | 			$classes = [];
115 | 			if ($event->owner_guid === elgg_get_logged_in_user_guid()) {
116 | 				$classes[] = 'event-manager-event-owner';
117 | 			} elseif ($event->getRelationshipByUser()) {
118 | 				$classes[] = 'event-manager-event-attending';
119 | 			}
120 | 			
121 | 			$event_result = [
122 | 				'guid' => $event->guid,
123 | 				'title' => $event->getDisplayName(),
124 | 				'start' => $start,
125 | 				'end' => $end,
126 | 				'allDay' => $all_day,
127 | 				'url' => $event->getURL(),
128 | 				'className' => $classes,
129 | 			];
130 | 			
131 | 			$result[] = $event_result;
132 | 		}
133 | 		
134 | 		return elgg_ok_response(json_encode($result));
135 | 	}
136 | }
137 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/Event/Day.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ColdTrick\EventManager\Event;
 4 | 
 5 | /**
 6 |  * Event day
 7 |  */
 8 | class Day extends \ElggObject {
 9 | 	
10 | 	const SUBTYPE = 'eventday';
11 | 
12 | 	/**
13 | 	 * {@inheritdoc}
14 | 	 */
15 | 	protected function initializeAttributes() {
16 | 		parent::initializeAttributes();
17 | 
18 | 		$this->attributes['subtype'] = self::SUBTYPE;
19 | 	}
20 | 
21 | 	/**
22 | 	 * Returns the slots
23 | 	 *
24 | 	 * @return array
25 | 	 */
26 | 	public function getEventSlots(): array {
27 | 		return elgg_call(ELGG_IGNORE_ACCESS, function() {
28 | 			return elgg_get_entities([
29 | 				'type' => 'object',
30 | 				'subtype' => Slot::SUBTYPE,
31 | 				'relationship_guid' => $this->guid,
32 | 				'relationship' => 'event_day_slot_relation',
33 | 				'inverse_relationship' => true,
34 | 				'sort_by' => [
35 | 					'property' => 'start_time',
36 | 					'signed' => true,
37 | 				],
38 | 				'limit' => false,
39 | 			]);
40 | 		});
41 | 	}
42 | }
43 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/Event/Slot.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ColdTrick\EventManager\Event;
 4 | 
 5 | /**
 6 |  * Event slot
 7 |  */
 8 | class Slot extends \ElggObject {
 9 | 	
10 | 	const SUBTYPE = 'eventslot';
11 | 
12 | 	/**
13 | 	 * {@inheritdoc}
14 | 	 */
15 | 	protected function initializeAttributes() {
16 | 		parent::initializeAttributes();
17 | 
18 | 		$this->attributes['subtype'] = self::SUBTYPE;
19 | 	}
20 | 
21 | 	/**
22 | 	 * Counts the number of registrations
23 | 	 *
24 | 	 * @return int
25 | 	 */
26 | 	public function countRegistrations(): int {
27 | 		return elgg_call(ELGG_IGNORE_ACCESS, function() {
28 | 			return elgg_count_entities([
29 | 				'relationship' => EVENT_MANAGER_RELATION_SLOT_REGISTRATION,
30 | 				'relationship_guid' => $this->guid,
31 | 				'inverse_relationship' => true,
32 | 			]);
33 | 		});
34 | 	}
35 | 
36 | 	/**
37 | 	 * Returns if the slot has a spot left
38 | 	 *
39 | 	 * @return boolean
40 | 	 */
41 | 	public function hasSpotsLeft(): bool {
42 | 		if (empty($this->max_attendees) || (($this->max_attendees - $this->countRegistrations()) > 0)) {
43 | 			return true;
44 | 		}
45 | 
46 | 		return false;
47 | 	}
48 | 
49 | 	/**
50 | 	 * Returns the users waiting for this slot
51 | 	 *
52 | 	 * @param boolean $count if a count should be returned, or the entity
53 | 	 *
54 | 	 * @return int|array
55 | 	 */
56 | 	public function getWaitingUsers(bool $count = false): int|array {
57 | 		return elgg_call(ELGG_IGNORE_ACCESS, function() use ($count) {
58 | 			if ($count) {
59 | 				return $this->countEntitiesFromRelationship(EVENT_MANAGER_RELATION_SLOT_REGISTRATION_WAITINGLIST, true);
60 | 			}
61 | 			
62 | 			return $this->getEntitiesFromRelationship([
63 | 				'relationship' => EVENT_MANAGER_RELATION_SLOT_REGISTRATION_WAITINGLIST,
64 | 				'inverse_relationship' => true,
65 | 			]);
66 | 		});
67 | 	}
68 | }
69 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/Forms/EventMail.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ColdTrick\EventManager\Forms;
 4 | 
 5 | /**
 6 |  * Event mail entity
 7 |  */
 8 | class EventMail {
 9 | 	
10 | 	/**
11 | 	 * Constructor
12 | 	 *
13 | 	 * @param \Event $entity related event entity
14 | 	 */
15 | 	public function __construct(protected \Event $entity) {
16 | 	}
17 | 	
18 | 	/**
19 | 	 * Get the form body vars for the event mail form
20 | 	 *
21 | 	 * @return array
22 | 	 */
23 | 	public function __invoke(): array {
24 | 		$vars = [
25 | 			'title' => '',
26 | 			'description' => '',
27 | 			'recipients' => [
28 | 				EVENT_MANAGER_RELATION_ATTENDING,
29 | 			],
30 | 			'entity' => $this->entity,
31 | 		];
32 | 		
33 | 		$sticky = elgg_get_sticky_values('event_manager/event/mail');
34 | 		if (!empty($sticky)) {
35 | 			foreach ($sticky as $name => $value) {
36 | 				$vars[$name] = $value;
37 | 			}
38 | 			
39 | 			elgg_clear_sticky_form('event_manager/event/mail');
40 | 		}
41 | 		
42 | 		return $vars;
43 | 	}
44 | }
45 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/GroupToolContainerLogicCheck.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ColdTrick\EventManager;
 4 | 
 5 | use Elgg\Groups\ToolContainerLogicCheck;
 6 | 
 7 | /**
 8 |  * Prevent events from being created if the group tool option is disabled
 9 |  */
10 | class GroupToolContainerLogicCheck extends ToolContainerLogicCheck {
11 | 
12 | 	/**
13 | 	 * {@inheritdoc}
14 | 	 */
15 | 	public function getContentType(): string {
16 | 		return 'object';
17 | 	}
18 | 	
19 | 	/**
20 | 	 * {@inheritdoc}
21 | 	 */
22 | 	public function getContentSubtype(): string {
23 | 		return \Event::SUBTYPE;
24 | 	}
25 | 
26 | 	/**
27 | 	 * {@inheritdoc}
28 | 	 */
29 | 	public function getToolName(): string {
30 | 		return 'event_manager';
31 | 	}
32 | }
33 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/Icons.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ColdTrick\EventManager;
 4 | 
 5 | /**
 6 |  * Icon related callbacks
 7 |  */
 8 | class Icons {
 9 | 		
10 | 	/**
11 | 	 * Returns the user default icon for event registration objects
12 | 	 *
13 | 	 * @param \Elgg\Event $event 'entity:icon:url', 'object'
14 | 	 *
15 | 	 * @return null|string
16 | 	 */
17 | 	public static function getEventRegistrationIconURL(\Elgg\Event $event): ?string {
18 | 		
19 | 		$entity = $event->getEntityParam();
20 | 		if (!$entity instanceof \EventRegistration) {
21 | 			return null;
22 | 		}
23 | 		
24 | 		$type = $event->getParam('type', 'icon');
25 | 		$size = $event->getParam('size', 'medium');
26 | 		
27 | 		$entity_type = 'user';
28 | 		$entity_subtype = 'user';
29 | 
30 | 		$exts = ['svg', 'gif', 'png', 'jpg'];
31 | 
32 | 		foreach ($exts as $ext) {
33 | 			foreach ([$entity_subtype, 'default'] as $subtype) {
34 | 				if ($ext == 'svg' && elgg_view_exists("{$type}/{$entity_type}/{$subtype}.svg")) {
35 | 					return elgg_get_simplecache_url("{$type}/{$entity_type}/{$subtype}.svg");
36 | 				}
37 | 				
38 | 				if (elgg_view_exists("{$type}/{$entity_type}/{$subtype}/{$size}.{$ext}")) {
39 | 					return elgg_get_simplecache_url("{$type}/{$entity_type}/{$subtype}/{$size}.{$ext}");
40 | 				}
41 | 			}
42 | 		}
43 | 
44 | 		if (!elgg_view_exists("{$type}/default/{$size}.png")) {
45 | 			return null;
46 | 		}
47 | 		
48 | 		return elgg_get_simplecache_url("{$type}/default/{$size}.png");
49 | 	}
50 | }
51 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/Js.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ColdTrick\EventManager;
 4 | 
 5 | /**
 6 |  * Javascript related callbacks
 7 |  */
 8 | class Js {
 9 | 	
10 | 	/**
11 | 	 * Returns elgg.data config
12 | 	 *
13 | 	 * @param string \Elgg\Event $event 'elgg.data', 'page'
14 | 	 *
15 | 	 * @return array
16 | 	 */
17 | 	public static function getJsConfig(\Elgg\Event $event): array {
18 | 		$result = $event->getValue();
19 | 		
20 | 		$result['event_manager_osm_default_zoom'] = elgg_get_plugin_setting('osm_default_zoom', 'event_manager');
21 | 		$result['event_manager_osm_default_location_lat'] = elgg_get_plugin_setting('osm_default_location_lat', 'event_manager');
22 | 		$result['event_manager_osm_default_location_lng'] = elgg_get_plugin_setting('osm_default_location_lng', 'event_manager');
23 | 		
24 | 		return $result;
25 | 	}
26 | }
27 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/Menus/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ColdTrick\EventManager\Menus;
 4 | 
 5 | use Elgg\Menu\MenuItems;
 6 | 
 7 | /**
 8 |  * Filter menu related callbacks
 9 |  */
10 | class Filter {
11 | 	
12 | 	/**
13 | 	 * Add view types (listing/calendar/map) to the filter tabs
14 | 	 *
15 | 	 * @param \Elgg\Event $event 'register', 'menu:filter:events'
16 | 	 *
17 | 	 * @return MenuItems
18 | 	 */
19 | 	public static function registerViewTypes(\Elgg\Event $event): MenuItems {
20 | 		
21 | 		/* @var $items MenuItems */
22 | 		$items = $event->getValue();
23 | 		
24 | 		$list_type = get_input('list_type', 'list');
25 | 		
26 | 		$parent_name = "event-manager-{$list_type}";
27 | 		
28 | 		$items[] = \ElggMenuItem::factory([
29 | 			'name' => 'event-manager-list',
30 | 			'icon' => 'list',
31 | 			'text' => elgg_echo('viewtype:list'),
32 | 			'href' => elgg_http_add_url_query_elements(elgg_get_current_url(), [
33 | 				'list_type' => 'list',
34 | 				'limit' => null,
35 | 				'offset' => null,
36 | 			]),
37 | 			'parent_name' => $parent_name,
38 | 			'priority' => 100,
39 | 			'selected' => false,
40 | 		]);
41 | 		
42 | 		$items[] = \ElggMenuItem::factory([
43 | 			'name' => 'event-manager-calendar',
44 | 			'icon' => 'calendar-alt',
45 | 			'text' => elgg_echo('event_manager:list:navigation:calendar'),
46 | 			'href' => elgg_http_add_url_query_elements(elgg_get_current_url(), [
47 | 				'list_type' => 'calendar',
48 | 				'limit' => null,
49 | 				'offset' => null,
50 | 			]),
51 | 			'parent_name' => $parent_name,
52 | 			'priority' => 200,
53 | 			'selected' => false,
54 | 		]);
55 | 		
56 | 		if (event_manager_get_maps_provider() !== 'none') {
57 | 			$items[] = \ElggMenuItem::factory([
58 | 				'name' => 'event-manager-map',
59 | 				'icon' => 'map-marked-alt',
60 | 				'text' => elgg_echo('event_manager:list:navigation:onthemap'),
61 | 				'href' => elgg_http_add_url_query_elements(elgg_get_current_url(), [
62 | 					'list_type' => 'map',
63 | 					'limit' => null,
64 | 					'offset' => null,
65 | 				]),
66 | 				'parent_name' => $parent_name,
67 | 				'priority' => 300,
68 | 				'selected' => false,
69 | 			]);
70 | 		}
71 | 		
72 | 		/** @var $parent_item \ElggMenuItem */
73 | 		$parent_item = $items->get($parent_name);
74 | 		$parent_item->setHref(false);
75 | 		$parent_item->setParentName(false);
76 | 		$parent_item->setPriority(99999);
77 | 		$parent_item->setItemClass('event-manager-listing-sorting');
78 | 		$parent_item->setChildMenuOptions([
79 | 			'display' => 'dropdown',
80 | 			'data-position' => json_encode([
81 | 				'my' => 'right top',
82 | 				'at' => 'right bottom',
83 | 				'collision' => 'fit fit',
84 | 			]),
85 | 		]);
86 | 		
87 | 		return $items;
88 | 	}
89 | }
90 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/Menus/FilterEventAttendees.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ColdTrick\EventManager\Menus;
 4 | 
 5 | use Elgg\Menu\MenuItems;
 6 | 
 7 | /**
 8 |  * Register menu items in the filter:event/attendees menu
 9 |  */
10 | class FilterEventAttendees {
11 | 	
12 | 	/**
13 | 	 * Register the event relationship to the attendee listing
14 | 	 *
15 | 	 * @param \Elgg\Event $event 'register', 'menu:filter:event/attendees'
16 | 	 *
17 | 	 * @return null|MenuItems
18 | 	 */
19 | 	public static function registerAttendeeRelationships(\Elgg\Event $event): ?MenuItems {
20 | 		$entity = $event->getParam('event_entity');
21 | 		if (!$entity instanceof \Event) {
22 | 			return null;
23 | 		}
24 | 		
25 | 		$valid_relationships = $entity->getSupportedRelationships();
26 | 		if (count($valid_relationships) === 1) {
27 | 			return null;
28 | 		}
29 | 		
30 | 		/* @var $result MenuItems */
31 | 		$result = $event->getValue();
32 | 		
33 | 		foreach ($valid_relationships as $rel => $label) {
34 | 			$result[] = \ElggMenuItem::factory([
35 | 				'name' => $rel,
36 | 				'text' => $label,
37 | 				'href' => elgg_generate_url('collection:object:event:attendees', [
38 | 					'guid' => $entity->guid,
39 | 					'relationship' => $rel,
40 | 				]),
41 | 			]);
42 | 		}
43 | 		
44 | 		return $result;
45 | 	}
46 | }
47 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/Menus/Site.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ColdTrick\EventManager\Menus;
 4 | 
 5 | use Elgg\Menu\MenuItems;
 6 | 
 7 | /**
 8 |  * Site menu related callbacks
 9 |  */
10 | class Site {
11 | 	
12 | 	/**
13 | 	 * Adds items to the site menu
14 | 	 *
15 | 	 * @param \Elgg\Event $event 'register', 'menu:site'
16 | 	 *
17 | 	 * @return MenuItems
18 | 	 */
19 | 	public static function registerEvents(\Elgg\Event $event): MenuItems {
20 | 		
21 | 		$result = $event->getValue();
22 | 		
23 | 		$result[] = \ElggMenuItem::factory([
24 | 			'name' => 'event',
25 | 			'icon' => 'calendar-alt',
26 | 			'text' => elgg_echo('event_manager:menu:title'),
27 | 			'href' => elgg_generate_url('default:object:event'),
28 | 		]);
29 | 		
30 | 		return $result;
31 | 	}
32 | }
33 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/MigrateEvents.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ColdTrick\EventManager;
 4 | 
 5 | use ColdTrick\EntityTools\Migrate;
 6 | 
 7 | /**
 8 |  * Entity tools migrate
 9 |  */
10 | class MigrateEvents extends Migrate {
11 | 	
12 | 	/**
13 | 	 * Add events to the supported types for EntityTools
14 | 	 *
15 | 	 * @param \Elgg\Event $event 'supported_types', 'entity_tools'
16 | 	 *
17 | 	 * @return array
18 | 	 */
19 | 	public static function supportedSubtypes(\Elgg\Event $event): array {
20 | 		
21 | 		$result = $event->getValue();
22 | 		
23 | 		$result[\Event::SUBTYPE] = static::class;
24 | 		
25 | 		return $result;
26 | 	}
27 | 	
28 | 	/**
29 | 	 * {@inheritdoc}
30 | 	 */
31 | 	public function canBackDate(): bool {
32 | 		return true;
33 | 	}
34 | 	
35 | 	/**
36 | 	 * {@inheritdoc}
37 | 	 */
38 | 	public function canChangeContainer(): bool {
39 | 		return true;
40 | 	}
41 | 	
42 | 	/**
43 | 	 * {@inheritdoc}
44 | 	 */
45 | 	public function canChangeOwner(): bool {
46 | 		return true;
47 | 	}
48 | }
49 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/Notifications.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ColdTrick\EventManager;
 4 | 
 5 | use Elgg\Email;
 6 | use Elgg\Email\Address;
 7 | use Elgg\Notifications\NotificationEvent;
 8 | use Elgg\Notifications\Notification;
 9 | 
10 | /**
11 |  * Notifications related callbacks
12 |  */
13 | class Notifications {
14 | 
15 | 	/**
16 | 	 * Make sure EventRegistration entities are never the sender of an e-mail
17 | 	 *
18 | 	 * To prevent e-mail exposure
19 | 	 *
20 | 	 * @param \Elgg\Event $event 'prepare', 'system:email'
21 | 	 *
22 | 	 * @return void|\Elgg\Email
23 | 	 */
24 | 	public static function prepareEventRegistrationSender(\Elgg\Event $event) {
25 | 		
26 | 		$email = $event->getValue();
27 | 		if (!$email instanceof Email) {
28 | 			return;
29 | 		}
30 | 		
31 | 		if (!$email->getSender() instanceof \EventRegistration) {
32 | 			return;
33 | 		}
34 | 		
35 | 		$site = elgg_get_site_entity();
36 | 		
37 | 		$email->setSender($site);
38 | 		$email->setFrom(new Address($site->getEmailAddress(), $site->getDisplayName()));
39 | 		
40 | 		return $email;
41 | 	}
42 | 	
43 | 	/**
44 | 	 * Send the notification to the mail owner and cleanup the event mail object
45 | 	 *
46 | 	 * @param \Elgg\Event $elgg_event 'send:after', 'notifications'
47 | 	 *
48 | 	 * @return void
49 | 	 */
50 | 	public static function sendAfterEventMail(\Elgg\Event $elgg_event): void {
51 | 		
52 | 		$event = $elgg_event->getParam('event');
53 | 		if (!$event instanceof NotificationEvent) {
54 | 			return;
55 | 		}
56 | 		
57 | 		$entity = $event->getObject();
58 | 		if (!$entity instanceof \EventMail) {
59 | 			return;
60 | 		}
61 | 		
62 | 		// remove the mail entity
63 | 		$entity->delete();
64 | 	}
65 | }
66 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/Notifications/CreateEventMailEventHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ColdTrick\EventManager\Notifications;
 4 | 
 5 | use Elgg\Notifications\NotificationEventHandler;
 6 | 
 7 | /**
 8 |  * Notification Event Handler for 'object' 'eventmail' 'create' action
 9 |  */
10 | class CreateEventMailEventHandler extends NotificationEventHandler {
11 | 
12 | 	/**
13 | 	 * {@inheritdoc}
14 | 	 */
15 | 	protected function getNotificationSubject(\ElggUser $recipient, string $method): string {
16 | 		$entity = $this->event->getObject();
17 | 		$container = $entity->getContainerEntity();
18 | 		
19 | 		return elgg_echo('event_manager:mail:notification:subject', [
20 | 			$container->getDisplayName(),
21 | 			$entity->getDisplayName(),
22 | 		], $recipient->getLanguage());
23 | 	}
24 | 	
25 | 	/**
26 | 	 * {@inheritdoc}
27 | 	 */
28 | 	protected function getNotificationBody(\ElggUser $recipient, string $method): string {
29 | 		$entity = $this->event->getObject();
30 | 		$container = $entity->getContainerEntity();
31 | 		
32 | 		return elgg_echo('event_manager:mail:notification:body', [
33 | 			$entity->description,
34 | 			$container->getURL(),
35 | 		], $recipient->getLanguage());
36 | 	}
37 | 
38 | 	/**
39 | 	 * Return EventMail subscriptions
40 | 	 *
41 | 	 * {@inheritdoc}
42 | 	 */
43 | 	public function getSubscriptions(): array {
44 | 		return $this->event->getObject()->getMailSubscriptions();
45 | 	}
46 | 	
47 | 	/**
48 | 	 * {@inheritdoc}
49 | 	 */
50 | 	public static function isConfigurableByUser(): bool {
51 | 		return false;
52 | 	}
53 | }
54 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/ObjectPicker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ColdTrick\EventManager;
 4 | 
 5 | /**
 6 |  * Objectpicker related callbacks
 7 |  */
 8 | class ObjectPicker {
 9 | 	
10 | 	/**
11 | 	 * Adds custom text for the objectpicker
12 | 	 *
13 | 	 * @param \Elgg\Event $elgg_event 'view_vars', 'input/objectpicker/item'
14 | 	 *
15 | 	 * @return null|array
16 | 	 */
17 | 	public static function customText(\Elgg\Event $elgg_event): ?array {
18 | 		$vars = $elgg_event->getValue();
19 | 		$entity = elgg_extract('entity', $vars);
20 | 		if (!$entity instanceof \Event) {
21 | 			return null;
22 | 		}
23 | 		
24 | 		$text = $entity->getDisplayName() . ' (' . event_manager_format_date($entity->getStartTimestamp()) . ')';
25 | 		$text .= elgg_format_element('div', ['class' => 'elgg-subtext'], $entity->getExcerpt(200));
26 | 		
27 | 		$vars['text'] = $text;
28 | 		
29 | 		return $vars;
30 | 	}
31 | }
32 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/Search.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ColdTrick\EventManager;
 4 | 
 5 | /**
 6 |  * Search related callbacks
 7 |  */
 8 | class Search {
 9 | 	
10 | 	/**
11 | 	 * Add searchable fields for events
12 | 	 *
13 | 	 * @param \Elgg\Event $event 'search:fields', 'object:event'
14 | 	 *
15 | 	 * @return array
16 | 	 */
17 | 	public static function addFields(\Elgg\Event $event): array {
18 | 		
19 | 		$value = (array) $event->getValue();
20 | 		
21 | 		$defaults = [
22 | 			'metadata' => [],
23 | 		];
24 | 		
25 | 		$value = array_merge($defaults, $value);
26 | 		
27 | 		$fields = [
28 | 			'event_type',
29 | 			'location',
30 | 			'region',
31 | 			'shortdescription',
32 | 		];
33 | 		
34 | 		$value['metadata'] = array_merge($value['metadata'], $fields);
35 | 		
36 | 		return $value;
37 | 	}
38 | 	
39 | 	/**
40 | 	 * Add metadata names to be exported to Elasticsearch index
41 | 	 *
42 | 	 * @param \Elgg\Event $event 'export:metadata_names', 'elasticsearch'|'opensearch'
43 | 	 *
44 | 	 * @return void|array
45 | 	 */
46 | 	public static function exportMetadataNames(\Elgg\Event $event) {
47 | 		
48 | 		$entity = $event->getEntityParam();
49 | 		if (!$entity instanceof \Event) {
50 | 			return;
51 | 		}
52 | 		
53 | 		$result = $event->getValue();
54 | 		
55 | 		$result[] = 'event_type';
56 | 		$result[] = 'location';
57 | 		$result[] = 'region';
58 | 		$result[] = 'shortdescription';
59 | 		
60 | 		return $result;
61 | 	}
62 | }
63 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/Views.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ColdTrick\EventManager;
 4 | 
 5 | /**
 6 |  * Views related callbacks
 7 |  */
 8 | class Views {
 9 | 	
10 | 	/**
11 | 	 * Loads leaflet css if needed
12 | 	 *
13 | 	 * @param \Elgg\Event $event 'view_vars', 'event_manager/listing/map'
14 | 	 *
15 | 	 * @return void
16 | 	 */
17 | 	public static function loadLeafletCss(\Elgg\Event $event) {
18 | 		if (event_manager_get_maps_provider() !== 'osm') {
19 | 			return;
20 | 		}
21 | 		
22 | 		elgg_load_external_file('css', 'leafletjs');
23 | 	}
24 | }
25 | 


--------------------------------------------------------------------------------
/classes/ColdTrick/EventManager/Widgets.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ColdTrick\EventManager;
 4 | 
 5 | /**
 6 |  * Widget related callbacks
 7 |  */
 8 | class Widgets {
 9 | 	
10 | 	/**
11 | 	 * Generates correct title link for widgets depending on the context
12 | 	 *
13 | 	 * @param \Elgg\Event $event 'entity:url', 'object'
14 | 	 *
15 | 	 * @return null|string
16 | 	 */
17 | 	public static function getEventsUrl(\Elgg\Event $event): ?string {
18 | 		
19 | 		$widget = $event->getEntityParam();
20 | 		if (!empty($event->getValue()) || !$widget instanceof \ElggWidget || $widget->handler !== 'events') {
21 | 			return null;
22 | 		}
23 | 			
24 | 		switch ($widget->context) {
25 | 			case 'index':
26 | 				if ($widget->event_status === 'live') {
27 | 					return elgg_generate_url('collection:object:event:live');
28 | 				}
29 | 				return elgg_generate_url('collection:object:event:upcoming');
30 | 			case 'groups':
31 | 				if ($widget->event_status === 'live') {
32 | 					return elgg_generate_url('collection:object:event:live', ['guid' => $widget->getOwnerGUID()]);
33 | 				}
34 | 				return elgg_generate_url('collection:object:event:group', ['guid' => $widget->getOwnerGUID()]);
35 | 		}
36 | 		
37 | 		return null;
38 | 	}
39 | 
40 | 	/**
41 | 	 * Registers the widget handlers for events
42 | 	 *
43 | 	 * @param \Elgg\Event $event 'handlers', 'widgets'
44 | 	 *
45 | 	 * @return null|array
46 | 	 */
47 | 	public static function registerHandlers(\Elgg\Event $event): ?array {
48 | 		
49 | 		$container = $event->getParam('container');
50 | 		if (!$container instanceof \ElggGroup) {
51 | 			return null;
52 | 		}
53 | 		
54 | 		if ($container->isToolEnabled('event_manager')) {
55 | 			return null;
56 | 		}
57 | 		
58 | 		$result = $event->getValue();
59 | 		foreach ($result as $index => $widget) {
60 | 			if ($widget->id === 'events') {
61 | 				unset($result[$index]);
62 | 				return $result;
63 | 			}
64 | 		}
65 | 
66 | 		return $result;
67 | 	}
68 | 	
69 | 	/**
70 | 	 * Change the entity_timestamp in the content_by_tag widget to show the start date of the event
71 | 	 *
72 | 	 * @param \Elgg\Event $event 'view_vars', 'widgets/content_by_tag/display/[simple|slim]'
73 | 	 *
74 | 	 * @return null|array
75 | 	 */
76 | 	public static function contentByTagEntityTimestamp(\Elgg\Event $event): ?array {
77 | 		$vars = $event->getValue();
78 | 		
79 | 		$entity = elgg_extract('entity', $vars);
80 | 		if (!$entity instanceof \Event) {
81 | 			return null;
82 | 		}
83 | 		
84 | 		$vars['entity_timestamp'] = $entity->getStartTimestamp();
85 | 		
86 | 		return $vars;
87 | 	}
88 | }
89 | 


--------------------------------------------------------------------------------
/classes/EventMail.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Mail object to be sent to all event attendees
 5 |  *
 6 |  * @property string[] $recipients who are the recipients of the mail
 7 |  */
 8 | class EventMail extends \ElggObject {
 9 | 	
10 | 	const SUBTYPE = 'eventmail';
11 | 	
12 | 	/**
13 | 	 * {@inheritdoc}
14 | 	 */
15 | 	protected function initializeAttributes() {
16 | 		parent::initializeAttributes();
17 | 		
18 | 		$this->attributes['subtype'] = self::SUBTYPE;
19 | 		$this->attributes['access_id'] = ACCESS_LOGGED_IN;
20 | 	}
21 | 	
22 | 	/**
23 | 	 * Get the subscriptions for the mail notification, based on the form settings
24 | 	 *
25 | 	 * @return array
26 | 	 */
27 | 	public function getMailSubscriptions(): array {
28 | 		$result = [
29 | 			$this->owner_guid => ['email'],
30 | 		];
31 | 		
32 | 		/* @var $event \Event */
33 | 		$event = $this->getContainerEntity();
34 | 		$row_to_guid = function($row) {
35 | 			return (int) $row->guid;
36 | 		};
37 | 		
38 | 		$recipients = $this->recipients;
39 | 		if (empty($recipients)) {
40 | 			// how is this possible?
41 | 			return $result;
42 | 		}
43 | 		
44 | 		if (!is_array($recipients)) {
45 | 			$recipients = [$recipients];
46 | 		}
47 | 		
48 | 		foreach ($recipients as $recipient_type) {
49 | 			switch ($recipient_type) {
50 | 				case 'contacts':
51 | 					$guids = $event->getContacts([
52 | 						'callback' => $row_to_guid,
53 | 					]);
54 | 					break;
55 | 				case EVENT_MANAGER_RELATION_ORGANIZING:
56 | 					// no longer a relationship
57 | 					$guids = $event->getOrganizers([
58 | 						'callback' => $row_to_guid,
59 | 					]);
60 | 					break;
61 | 				default:
62 | 					// default relationships
63 | 					$guids = $event->getEntitiesFromRelationship([
64 | 						'relationship' => $recipient_type,
65 | 						'limit' => false,
66 | 						'callback' => $row_to_guid,
67 | 					]);
68 | 					break;
69 | 			}
70 | 			
71 | 			foreach ($guids as $guid) {
72 | 				$result[$guid] = ['email'];
73 | 			}
74 | 		}
75 | 		
76 | 		return $result;
77 | 	}
78 | }
79 | 


--------------------------------------------------------------------------------
/classes/EventRegistration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * EventRegistration
 5 |  *
 6 |  * @property string $name  the name of the user
 7 |  * @property string $email the e-mail address of the user
 8 |  */
 9 | class EventRegistration extends \ElggObject {
10 | 	
11 | 	const SUBTYPE = 'eventregistration';
12 | 
13 | 	/**
14 | 	 * {@inheritdoc}
15 | 	 */
16 | 	protected function initializeAttributes() {
17 | 		parent::initializeAttributes();
18 | 
19 | 		$this->attributes['subtype'] = self::SUBTYPE;
20 | 		$this->attributes['access_id'] = ACCESS_PUBLIC;
21 | 	}
22 | 	
23 | 	/**
24 | 	 * Allow non-user to remove their registration correctly
25 | 	 *
26 | 	 * {@inheritdoc}
27 | 	 */
28 | 	public function canEdit(int $user_guid = 0): bool {
29 | 		global $EVENT_MANAGER_UNDO_REGISTRATION;
30 | 	
31 | 		if (!empty($EVENT_MANAGER_UNDO_REGISTRATION)) {
32 | 			return true;
33 | 		}
34 | 
35 | 		return parent::canEdit($user_guid);
36 | 	}
37 | 	
38 | 	/**
39 | 	 * {@inheritdoc}
40 | 	 */
41 | 	public function getDisplayName(): string {
42 | 		return $this->name ?? parent::getDisplayName();
43 | 	}
44 | }
45 | 


--------------------------------------------------------------------------------
/classes/EventRegistrationQuestion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * EventRegistrationQuestion
 4 |  *
 5 |  * @property string $fieldtype    input type if the question
 6 |  * @property string $fieldoptions input options for the question
 7 |  * @property int    $order        order of the question
 8 |  * @property int    $required     input is required
 9 |  */
10 | class EventRegistrationQuestion extends \ElggObject {
11 | 	
12 | 	const SUBTYPE = 'eventregistrationquestion';
13 | 
14 | 	/**
15 | 	 * {@inheritdoc}
16 | 	 */
17 | 	protected function initializeAttributes() {
18 | 		parent::initializeAttributes();
19 | 
20 | 		$this->attributes['subtype'] = self::SUBTYPE;
21 | 	}
22 | 
23 | 	/**
24 | 	 * Returns the answer given by a user
25 | 	 *
26 | 	 * @param int $user_guid guid of the entity
27 | 	 *
28 | 	 * @return null|\ElggAnnotation
29 | 	 */
30 | 	public function getAnswerFromUser(int $user_guid = 0): ?\ElggAnnotation {
31 | 		$annotations = elgg_get_annotations([
32 | 			'guid' => $this->guid,
33 | 			'annotation_name' => 'answer_to_event_registration',
34 | 			'annotation_owner_guid' => $user_guid ?: elgg_get_logged_in_user_guid(),
35 | 			'limit' => 1,
36 | 		]);
37 | 		
38 | 		return elgg_extract(0, $annotations);
39 | 	}
40 | 
41 | 	/**
42 | 	 * Removes the answer given by a user
43 | 	 *
44 | 	 * @param int $user_guid guid of the entity
45 | 	 *
46 | 	 * @return void
47 | 	 */
48 | 	public function deleteAnswerFromUser(int $user_guid = 0): void {
49 | 		$user_guid = $user_guid ?: elgg_get_logged_in_user_guid();
50 | 
51 | 		$this->getAnswerFromUser($user_guid)?->delete();
52 | 	}
53 | 
54 | 	/**
55 | 	 * Updates the answer given by a user
56 | 	 *
57 | 	 * @param Event  $event      the event entity used for setting the access of the annotation correctly
58 | 	 * @param string $new_answer the new answer
59 | 	 * @param int    $user_guid  guid of the entity giving the answer
60 | 	 *
61 | 	 * @return void
62 | 	 */
63 | 	public function updateAnswerFromUser(\Event $event, string $new_answer, int $user_guid = 0): void {
64 | 		$user_guid = $user_guid ?: elgg_get_logged_in_user_guid();
65 | 		
66 | 		$old_answer = $this->getAnswerFromUser($user_guid);
67 | 		if ($old_answer && get_user($user_guid)) {
68 | 			if (!empty($new_answer)) {
69 | 				$old_answer->setValue($new_answer);
70 | 				$old_answer->save();
71 | 			} else {
72 | 				elgg_delete_annotation_by_id($old_answer->id);
73 | 			}
74 | 		} else {
75 | 			$this->annotate('answer_to_event_registration', $new_answer, $event->access_id, $user_guid);
76 | 		}
77 | 	}
78 | 
79 | 	/**
80 | 	 * Returns the options of this question
81 | 	 *
82 | 	 * @return array
83 | 	 */
84 | 	public function getOptions(): array {
85 | 		$field_options = [];
86 | 
87 | 		if (!empty($this->fieldoptions)) {
88 | 			$field_options = elgg_string_to_array($this->fieldoptions);
89 | 			$field_options = array_combine(array_values($field_options), $field_options); // input radio and checkbox require non-numeric keys
90 | 		}
91 | 
92 | 		return $field_options;
93 | 	}
94 | }
95 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name": "coldtrick/event_manager",
 3 | 	"description": "Manage events, from a simple appointment to a multi day event with day programs and subscriptions",
 4 | 	"homepage": "https://www.coldtrick.com",
 5 | 	"type": "elgg-plugin",
 6 | 	"keywords": ["elgg", "plugin", "events"],
 7 | 	"license": "GPL-2.0-only",
 8 | 	"support": {
 9 | 		"source": "https://github.com/ColdTrick/event_manager",
10 | 		"issues": "https://github.com/ColdTrick/event_manager/issues"
11 | 	},
12 | 	"require": {
13 | 		"dompdf/dompdf" : "~3.0.0",
14 | 		"npm-asset/fullcalendar": "~6.1.0"
15 | 	},
16 | 	"repositories": [
17 | 		{
18 |             "type": "composer",
19 |             "url": "https://asset-packagist.org"
20 | 		}
21 | 	],
22 | 	"config": {
23 | 		"fxp-asset": {
24 |             "enabled": false
25 | 		}
26 | 	},
27 | 	"conflict": {
28 | 		"elgg/elgg": "<6.0"
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/views/default/event_manager/addthisevent/button.css:
--------------------------------------------------------------------------------
 1 | .addeventatc_dropdown {
 2 | 	display: none;
 3 | 	right: 0px;
 4 | 	left: unset !important;
 5 | 	position: absolute;
 6 | 	top: unset !important;
 7 | 	z-index: 1;
 8 | 	background: white;
 9 | 	border: 1px solid #CCC;
10 | 	
11 | 	span {
12 | 		display: block;
13 | 		white-space: nowrap;
14 | 		color: $(text-color-strong);
15 | 		padding: 5px 15px;
16 | 		
17 | 		&:hover {
18 | 			background: $(background-color-soft);
19 | 			color: #333;
20 | 			cursor: pointer;
21 | 		}
22 | 	}
23 | }
24 | 


--------------------------------------------------------------------------------
/views/default/event_manager/addthisevent/button.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | elgg_import_esm('event_manager/addthisevent/button');
 4 | 
 5 | $event = elgg_extract('entity', $vars);
 6 | if (!$event) {
 7 | 	return;
 8 | }
 9 | 
10 | $location = $event->location ?: $event->venue;
11 | 
12 | $start = $event->getStartDate('d/m/Y H:i:00');
13 | $end = $event->getEndDate('d/m/Y H:i:00');
14 | 
15 | $title = html_entity_decode($event->getDisplayName());
16 | 
17 | $description = '';
18 | if (!empty($event->location)) {
19 | 	// add venue to description
20 | 	$description .= $event->venue . PHP_EOL;
21 | }
22 | 
23 | // removing HTML and shorter because of URL length limitations
24 | $description .= $event->getExcerpt(500) . PHP_EOL . PHP_EOL;
25 | $description .= $event->getURL();
26 | 
27 | ?>
28 | <span class="addeventatc" data-styling="none">
29 | 	<?php echo elgg_echo('event_manager:event:menu:title:add_to_calendar'); ?>
30 | 	<div class='hidden'>
31 | 		<span class="start"><?php echo $start; ?></span>
32 | 		<span class="end"><?php echo $end; ?></span>
33 | 		<span class="title"><?php echo $title; ?></span>
34 | 		<span class="location"><?php echo $location; ?></span>
35 | 		<span class="date_format">DD/MM/YYYY</span>
36 | 		<span class="description"><?php echo $description; ?></span>
37 | 	</div>
38 | </span>
39 | 


--------------------------------------------------------------------------------
/views/default/event_manager/addthisevent/email.css:
--------------------------------------------------------------------------------
 1 | .event-manager-email-addevent-title {
 2 | 	font-weight: bold;
 3 | }
 4 | 
 5 | .event-manager-email-addevent {
 6 | 	background: #EFEFEF;
 7 | 	border-radius: 4px;
 8 | 	padding: 5px 10px;
 9 | 	border: 1px solid #CCC;
10 | 	text-align: center;
11 | 	vertical-align: top;
12 | }
13 | .event-manager-email-addevent a {
14 | 	text-decoration: none;
15 | 	color: black;
16 | }
17 | 


--------------------------------------------------------------------------------
/views/default/event_manager/addthisevent/email.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Add links to the footer of the e-mail notification to add the event to your calendar
 4 |  *
 5 |  * @uses $vars['entity'] The event to generate links for
 6 |  */
 7 | 
 8 | if (elgg_get_plugin_setting('add_event_to_calendar', 'event_manager') === 'no') {
 9 | 	// setting set to not show links
10 | 	return;
11 | }
12 | 
13 | $event = elgg_extract('entity', $vars);
14 | if (!$event instanceof \Event) {
15 | 	return;
16 | }
17 | 
18 | $services = (array) elgg_extract('services', $vars, ['google', 'yahoo', 'office365', 'outlookcom', 'outlook', 'appleical']);
19 | $service_links = [];
20 | 
21 | foreach ($services as $service) {
22 | 	if (elgg_get_plugin_setting("show_service_{$service}", 'event_manager')) {
23 | 		$service_links[] = $service;
24 | 	}
25 | }
26 | 
27 | if (empty($service_links)) {
28 | 	return;
29 | }
30 | 
31 | echo '<br /><br />';
32 | echo elgg_format_element('span', ['class' => 'event-manager-email-addevent-title'], elgg_echo('event_manager:addevent:mail:title'));
33 | echo '<br /><br />';
34 | 
35 | $description = '';
36 | if (!empty($event->location)) {
37 | 	// add venue to description
38 | 	$description .= $event->venue . PHP_EOL;
39 | }
40 | 
41 | // removing HTML and shorter because of URL length limitations
42 | $description .= $event->getExcerpt(500) . PHP_EOL . PHP_EOL;
43 | $description .= $event->getURL();
44 | 
45 | $url_params = [
46 | 	'client' => elgg_get_plugin_setting('add_event_license', 'event_manager'),
47 | 	'date_format' => 'DD/MM/YYYY',
48 | 	'start' => $event->getStartDate('d/m/Y'),
49 | 	'starttime' => $event->getStartDate('H:i:00'),
50 | 	'end' => $event->getEndDate('d/m/Y'),
51 | 	'endtime' => $event->getEndDate('H:i:00'),
52 | 	'title' => $event->getDisplayName(),
53 | 	'location' => $event->location ?: $event->venue,
54 | 	'description' => $description,
55 | ];
56 | 
57 | echo '<table><tr>';
58 | foreach ($service_links as $service) {
59 | 	$url_params['service'] = $service;
60 | 
61 | 	echo elgg_format_element('td', [
62 | 		'class' => 'event-manager-email-addevent event-manager-email-addevent-' . $service,
63 | 	], elgg_view_url(elgg_http_add_url_query_elements('https://addevent.com/dir/', $url_params), elgg_echo('event_manager:addevent:mail:service:' . $service)));
64 | }
65 | 
66 | echo '</tr></table>';
67 | 


--------------------------------------------------------------------------------
/views/default/event_manager/addthisevent/settings.js.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | $get_setting = function ($service) {
 3 | 	return elgg_get_plugin_setting("show_service_{$service}", 'event_manager') ? 'true' : 'false';
 4 | };
 5 | ?>
 6 | 
 7 | window.addeventasync = function(){
 8 | 	addeventatc.settings({
 9 | 		license: "<?php echo elgg_get_plugin_setting('add_event_license', 'event_manager');?>",
10 | 		mouse: false,
11 | 		css: false,
12 | 		google: {show:<?php echo $get_setting('google');?>, text:"Google <em>(online)</em>"},
13 | 		yahoo: {show:<?php echo $get_setting('yahoo');?>, text:"Yahoo <em>(online)</em>"},
14 | 		office365: {show:<?php echo $get_setting('office365');?>, text:"Office 365 <em>(online)</em>"},
15 | 		outlookcom: {show:<?php echo $get_setting('outlookcom');?>, text:"Outlook.com <em>(online)</em>"},
16 | 		outlook: {show:<?php echo $get_setting('outlook');?>, text:"Outlook"},
17 | 		appleical: {show:<?php echo $get_setting('appleical');?>, text:"iCal Calendar"},
18 | 		dropdown: {order:"google,yahoo,office365,outlookcom,outlook,appleical"}
19 | 	});
20 | };
21 | 


--------------------------------------------------------------------------------
/views/default/event_manager/event/attendees_list.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Show a list of attendees to an event
 4 |  *
 5 |  * @uses $vars['entity']       Event to show attendees for
 6 |  * @uses $vars['relationship'] which attendees to list
 7 |  */
 8 | 
 9 | use Elgg\Database\Clauses\OrderByClause;
10 | 
11 | $guid = get_input('guid');
12 | $entity = elgg_extract('entity', $vars);
13 | $relationship = elgg_extract('relationship', $vars, get_input('relationship'));
14 | 
15 | if (!$entity && $guid) {
16 | 	$entity = get_entity($guid);
17 | }
18 | 
19 | if (!$entity instanceof \Event || empty($relationship)) {
20 | 	return;
21 | }
22 | 
23 | $options = [
24 | 	'type' => 'user', // trigger search fields generation
25 | 	'type_subtype_pairs' => [
26 | 		'user' => ELGG_ENTITIES_ANY_VALUE,
27 | 		'object' => [
28 | 			EventRegistration::SUBTYPE,
29 | 		],
30 | 	],
31 | 	'relationship_guid' => $entity->guid,
32 | 	'relationship' => $relationship,
33 | 	'no_results' => true,
34 | 	'order_by' => new OrderByClause('r.time_created', 'DESC'),
35 | ];
36 | 
37 | $getter = 'elgg_get_entities';
38 | 
39 | // searching ?
40 | $q = elgg_extract('q', $vars, get_input('q'));
41 | if (!empty($q)) {
42 | 	$options['query'] = $q;
43 | 	// fix pagination
44 | 	$options['base_url'] = elgg_generate_url('collection:object:event:attendees', [
45 | 		'guid' => $entity->guid,
46 | 		'relationship' => $relationship,
47 | 		'q' => $q,
48 | 	]);
49 | 		
50 | 	$getter = 'elgg_search';
51 | }
52 | 
53 | echo elgg_list_entities($options, $getter);
54 | 


--------------------------------------------------------------------------------
/views/default/event_manager/event/files.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 	
 3 | $event = elgg_extract('entity', $vars);
 4 | if (!$event instanceof \Event) {
 5 | 	return;
 6 | }
 7 | 
 8 | $files = $event->getFiles();
 9 | if (empty($files)) {
10 | 	return;
11 | }
12 | 
13 | $rows = '';
14 | $elggfile = new \ElggFile();
15 | $elggfile->owner_guid = $event->guid;
16 | 
17 | $use_cookie = ($event->access_id !== ACCESS_PUBLIC);
18 | 
19 | foreach ($files as $file) {
20 | 	$elggfile->setFilename($file->file);
21 | 	
22 | 	if (!$elggfile->exists()) {
23 | 		// check old storage location
24 | 		$elggfile->setFilename("files/{$file->file}");
25 | 	}
26 | 		
27 | 	$link = elgg_view_url(elgg_get_download_url($elggfile, $use_cookie), $file->title);
28 | 	
29 | 	$delete = elgg_view('output/url', [
30 | 		'href' => elgg_generate_action_url('event_manager/event/deletefile', [
31 | 			'guid' => $event->guid,
32 | 			'file' => $file->file,
33 | 		]),
34 | 		'icon' => 'delete',
35 | 		'text' => elgg_echo('delete'),
36 | 		'confirm' => true,
37 | 	]);
38 | 	
39 | 	$rows .= "<tr><td>{$link}</td><td>{$delete}</td></tr>";
40 | }
41 | 
42 | $content = elgg_format_element('table', ['class' => 'elgg-table'], $rows);
43 | 	
44 | echo elgg_view_module('info', elgg_echo('event_manager:edit:form:files'), $content, ['class' => 'mtm']);
45 | 


--------------------------------------------------------------------------------
/views/default/event_manager/event/pdf.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event = elgg_extract('entity', $vars);
 4 | 
 5 | if ($event->hasIcon('header', 'header')) {
 6 | 	$header_icon = $event->getIcon('header', 'header');
 7 | 	
 8 | 	$filecontents = $header_icon->grabFile();
 9 | 
10 | 	echo '<div class="mbm elgg-border-plain center"><img style="width: 100%;" src="data:image/jpeg;base64,' . base64_encode($filecontents) . '" border="0" /></div>';
11 | }
12 | 
13 | $event_start = $event->getStartTimestamp();
14 | $event_end = $event->getEndTimestamp();
15 | 
16 | $when_title = elgg_echo('date:weekday:' . gmdate('w', $event_start)) . ', ';
17 | $when_title .= elgg_echo('date:month:' . gmdate('m', $event_start), [gmdate('j', $event_start)]) . ' ';
18 | $when_title .= gmdate('Y', $event_start);
19 | 
20 | $when_subtitle = '';
21 | 
22 | if (!$event_end) {
23 | 	$when_title .= ' ' . gmdate('H:i', $event_start);
24 | } else {
25 | 	if (gmdate('d-m-Y', $event_end) === gmdate('d-m-Y', $event_start)) {
26 | 		// same day event
27 | 		$when_subtitle .= gmdate('H:i', $event_start) . ' ' . strtolower(elgg_echo('event_manager:date:to')) . ' ' . gmdate('H:i', $event_end);
28 | 	} else {
29 | 		$when_title .= ' ' . gmdate('H:i', $event_start);
30 | 		$when_subtitle .= strtolower(elgg_echo('event_manager:date:to')) . ' ';
31 | 
32 | 		$when_subtitle .= elgg_echo('date:weekday:' . gmdate('w', $event_end)) . ', ';
33 | 		$when_subtitle .= elgg_echo('date:month:' . gmdate('m', $event_end), [gmdate('j', $event_end)]) . ' ';
34 | 		$when_subtitle .= gmdate('Y', $event_end) . ' ';
35 | 		$when_subtitle .= gmdate('H:i', $event_end);
36 | 	}
37 | }
38 | 
39 | $when = elgg_format_element('div', ['class' => 'event-manager-event-when-title'], $when_title);
40 | if (!empty($when_subtitle)) {
41 | 	$when .= elgg_format_element('div', ['class' => 'event-manager-event-when-subtitle'], $when_subtitle);
42 | }
43 | 
44 | echo elgg_view_image_block(elgg_view_icon('calendar', ['class' => 'elgg-icon-hover']), $when, ['class' => 'event-manager-event-when']);
45 | 
46 | // event details
47 | $location = $event->location;
48 | if ($location) {
49 | 	echo elgg_format_element('label', [], elgg_echo('event_manager:edit:form:location'));
50 | 	echo elgg_format_element('div', ['class' => 'mbm'], $location);
51 | }
52 | 
53 | $organizer = $event->organizer;
54 | if ($organizer) {
55 | 	echo elgg_format_element('label', [], elgg_echo('event_manager:edit:form:organizer'));
56 | 	echo elgg_format_element('div', ['class' => 'mbm'], $organizer);
57 | }
58 | 
59 | $description = $event->description;
60 | if ($description) {
61 | 	echo elgg_format_element('label', [], elgg_echo('description'));
62 | 	echo elgg_format_element('div', ['class' => 'mbm'], elgg_view('output/longtext', ['value' => $description]));
63 | }
64 | 
65 | $region = $event->region;
66 | if ($region) {
67 | 	echo elgg_format_element('label', [], elgg_echo('event_manager:edit:form:region'));
68 | 	echo elgg_format_element('div', ['class' => 'mbm'], $region);
69 | }
70 | 
71 | $type = $event->event_type;
72 | if ($type) {
73 | 	echo elgg_format_element('label', [], elgg_echo('event_manager:edit:form:type'));
74 | 	echo elgg_format_element('div', ['class' => 'mbm'], $type);
75 | }
76 | 


--------------------------------------------------------------------------------
/views/default/event_manager/event/popup.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * @var \Event $event
 5 |  */
 6 | $event = elgg_extract('entity', $vars);
 7 | $result = '';
 8 | 
 9 | $title = elgg_view('event_manager/event/view/banner', $vars);
10 | $title .= elgg_view_title($event->getDisplayName(), [
11 | 	'class' => 'elgg-heading-main',
12 | ]);
13 | 
14 | $result .= elgg_format_element('div', ['class' => 'event-manager-popup-title'], $title);
15 | 
16 | $datetime = elgg_view('event_manager/event/view/datetime', $vars);
17 | $registration = elgg_view('event_manager/event/view/registration', $vars + ['show_rsvp' => false]);
18 | 
19 | $result .= elgg_format_element('div', ['class' => 'event-manager-header'], $datetime . $registration);
20 | 
21 | // description
22 | $description = $event->description ? elgg_get_excerpt($event->description, 500) : $event->shortdescription;
23 | if (!empty($description)) {
24 | 	$result .= elgg_view_module('event', '', elgg_view('output/longtext', ['value' => $description]));
25 | }
26 | 
27 | $location = '';
28 | if ($event->location) {
29 | 	$location_details = elgg_format_element('label', [], elgg_echo('event_manager:edit:form:location'));
30 | 	$location_details .= elgg_format_element('div', ['class' => 'mrl'], elgg_view_url($event->getURL() . '#location', $event->location));
31 | 	
32 | 	$location = elgg_format_element('div', [], $location_details);
33 | }
34 | 
35 | $event_link = elgg_view('output/url', [
36 | 	'href' => $event->getURL(),
37 | 	'text' => elgg_echo('event_manager:popup:event_link'),
38 | 	'class' => ['elgg-button', 'elgg-button-action', 'mts'],
39 | ]);
40 | 
41 | $result .= elgg_format_element('div', ['class' => 'event-manager-popup-footer'], $location . $event_link);
42 | 
43 | $classes = ['event-manager-popup'];
44 | if ($event->owner_guid === elgg_get_logged_in_user_guid()) {
45 | 	$classes[] = 'event-manager-event-owner';
46 | } elseif ($event->getRelationshipByUser()) {
47 | 	$classes[] = 'event-manager-event-attending';
48 | }
49 | 
50 | echo elgg_format_element('div', ['class' => $classes], $result);
51 | 


--------------------------------------------------------------------------------
/views/default/event_manager/event/registration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event = elgg_extract('entity', $vars);
 4 | if (!$event || !elgg_is_logged_in()) {
 5 | 	return;
 6 | }
 7 | 
 8 | if (!$event->registration_needed) {
 9 | 	return;
10 | }
11 | 
12 | if (!$event->hasRelationship(elgg_get_logged_in_user_guid(), EVENT_MANAGER_RELATION_ATTENDING)) {
13 | 	return;
14 | }
15 | 
16 | echo elgg_view_url(elgg_generate_url('view:object:eventregistration', ['guid' => $event->guid]), elgg_echo('event_manager:registration:viewyourregistration'));
17 | 


--------------------------------------------------------------------------------
/views/default/event_manager/event/rsvp.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event = elgg_extract('entity', $vars);
 4 | if (!$event instanceof \Event) {
 5 | 	return;
 6 | }
 7 | 
 8 | if (elgg_in_context('widgets')) {
 9 | 	return;
10 | }
11 | 
12 | if (!elgg_extract('show_rsvp', $vars, true)) {
13 | 	return;
14 | }
15 | 
16 | $menu_vars = $vars;
17 | $menu_vars['class'] = ['elgg-menu-hz'];
18 | $menu = elgg_view_menu('event:rsvp', $menu_vars);
19 | if (empty($menu)) {
20 | 	return;
21 | }
22 | 
23 | echo $menu;
24 | 
25 | if (elgg_extract('full_view', $vars)) {
26 | 	$registration = elgg_view('event_manager/event/registration', $vars);
27 | 	if ($registration) {
28 | 		echo elgg_format_element('div', [], $registration);
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/views/default/event_manager/event/sidebar.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | echo elgg_view('event_manager/event/sidebar/attendees', $vars);
4 | 


--------------------------------------------------------------------------------
/views/default/event_manager/event/sidebar/attendees.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | $event = elgg_extract('entity', $vars);
 3 | if (!$event) {
 4 | 	return;
 5 | }
 6 | 
 7 | $relationships = $event->getRelationships();
 8 | 
 9 | $organizer_guids = $event->organizer_guids;
10 | if (!empty($organizer_guids)) {
11 | 	if (!array_key_exists(EVENT_MANAGER_RELATION_ORGANIZING, $relationships)) {
12 | 		$relationships[EVENT_MANAGER_RELATION_ORGANIZING] = [];
13 | 	}
14 | 	
15 | 	if (!is_array($organizer_guids)) {
16 | 		$organizer_guids = [$organizer_guids];
17 | 	}
18 | 	
19 | 	foreach ($organizer_guids as $organizer_guid) {
20 | 		$relationships[EVENT_MANAGER_RELATION_ORGANIZING][] = $organizer_guid;
21 | 	}
22 | }
23 | 
24 | if (empty($relationships)) {
25 | 	return;
26 | }
27 | 
28 | $ordered_relationships = [
29 | 	EVENT_MANAGER_RELATION_PRESENTING,
30 | 	EVENT_MANAGER_RELATION_EXHIBITING,
31 | 	EVENT_MANAGER_RELATION_ORGANIZING,
32 | ];
33 | 
34 | foreach ($ordered_relationships as $rel) {
35 | 	if (!array_key_exists($rel, $relationships)) {
36 | 		continue;
37 | 	}
38 | 	
39 | 	$members = $relationships[$rel];
40 | 
41 | 	$rel_title = elgg_echo("event_manager:event:relationship:{$rel}:label");
42 | 
43 | 	$rel_content = '';
44 | 	foreach ($members as $member) {
45 | 		$member_entity = get_entity($member);
46 | 		if (empty($member_entity)) {
47 | 			continue;
48 | 		}
49 | 
50 | 		$member_icon = elgg_view_entity_icon($member_entity, 'tiny', ['event' => $event]);
51 | 		$rel_content .= elgg_view_image_block($member_icon, elgg_view_entity_url($member_entity), ['class' => 'pan']);
52 | 	}
53 | 
54 | 	echo elgg_view_module('aside', $rel_title, $rel_content);
55 | }
56 | 


--------------------------------------------------------------------------------
/views/default/event_manager/event/view.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $datetime = elgg_view('event_manager/event/view/datetime', $vars);
 4 | $registration = elgg_view('event_manager/event/view/registration', $vars);
 5 | 
 6 | $body = elgg_format_element('div', ['class' => 'event-manager-header'], $datetime . $registration);
 7 | $body .= elgg_view('event_manager/event/view/description', $vars);
 8 | $body .= elgg_view('event_manager/event/view/contact_details', $vars);
 9 | $body .= elgg_view('event_manager/event/view/location', $vars);
10 | $body .= elgg_view('event_manager/program/view', $vars);
11 | $body .= elgg_view('event_manager/event/view/files', $vars);
12 | $body .= elgg_view('event_manager/event/view/attendees', $vars);
13 | 
14 | $params = [
15 | 	'body' => $body,
16 | 	'show_summary' => true,
17 | 	'show_navigation' => false,
18 | 	'icon' => false,
19 | ];
20 | $params = $params + $vars;
21 | 
22 | echo elgg_view('object/elements/full', $params);
23 | 


--------------------------------------------------------------------------------
/views/default/event_manager/event/view/attendees.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event = elgg_extract('entity', $vars);
 4 | if (!$event instanceof \Event) {
 5 | 	return;
 6 | }
 7 | 
 8 | if (!$event->show_attendees && !$event->canEdit()) {
 9 | 	return;
10 | }
11 | 
12 | $relationships = $event->getRelationships(false, 'DESC');
13 | if (empty($relationships)) {
14 | 	return;
15 | }
16 | 
17 | $supported_relationships = $event->getSupportedRelationships();
18 | $can_edit = $event->canEdit();
19 | 
20 | foreach ($supported_relationships as $rel => $label) {
21 | 	if (!array_key_exists($rel, $relationships)) {
22 | 		continue;
23 | 	}
24 | 	
25 | 	$members = $relationships[$rel];
26 | 	$total = count($members);
27 | 	$member_limit = 10;
28 | 	
29 | 	$rel_title = elgg_view('output/url', [
30 | 		'text' => "{$label} ({$total})",
31 | 		'href' => elgg_generate_url('collection:object:event:attendees', [
32 | 			'guid' => $event->guid,
33 | 			'relationship' => $rel,
34 | 		]),
35 | 	]);
36 | 	
37 | 	$rel_content = '';
38 | 	
39 | 	$first_guids = array_slice($members, 0, $member_limit);
40 | 	$first_entities = elgg_get_entities(['guids' => $first_guids]);
41 | 	$ordered_entities = array_flip($first_guids);
42 | 	foreach ($first_entities as $member) {
43 | 		$ordered_entities[$member->guid] = $member;
44 | 	}
45 | 	
46 | 	foreach ($ordered_entities as $member) {
47 | 		$rel_content .= elgg_view_entity_icon($member, 'small', ['class' => ['mrs', 'mbs']]);
48 | 	}
49 | 	
50 | 	if ($total > $member_limit) {
51 | 		$remaining = $total - $member_limit;
52 | 		
53 | 		$rel_content .= elgg_view('output/url', [
54 | 			'text' => elgg_echo('event_manager:event:view:attendees:more', [$remaining]),
55 | 			'href' => elgg_generate_url('collection:object:event:attendees', [
56 | 				'guid' => $event->guid,
57 | 				'relationship' => $rel,
58 | 			]),
59 | 			'class' => [
60 | 				'elgg-button',
61 | 				'elgg-button-action',
62 | 			],
63 | 		]);
64 | 	}
65 | 	
66 | 	$module_vars = [];
67 | 	
68 | 	if ($can_edit) {
69 | 		// export action
70 | 		$module_vars['menu'] = elgg_view('output/url', [
71 | 			'href' => elgg_generate_action_url('event_manager/attendees/export', [
72 | 				'guid' => $event->guid,
73 | 				'rel' => $rel,
74 | 			]),
75 | 			'title' => elgg_echo('event_manager:event:exportattendees'),
76 | 			'icon' => 'download',
77 | 			'text' => elgg_echo('download'),
78 | 		]);
79 | 	}
80 | 			
81 | 	echo elgg_view_module('info', $rel_title, $rel_content, $module_vars);
82 | }
83 | 


--------------------------------------------------------------------------------
/views/default/event_manager/event/view/banner.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event = elgg_extract('entity', $vars);
 4 | if (!$event instanceof \Event) {
 5 | 	return;
 6 | }
 7 | 
 8 | if (!$event->hasIcon('header', 'header')) {
 9 | 	return;
10 | }
11 | 
12 | $event_banner_url = $event->getIconURL(['type' => 'header', 'size' => 'header']);
13 | 
14 | echo elgg_format_element('div', [
15 | 	'class' => ['mbl', 'event-manager-event-banner'],
16 | 	'style' => "background-image: url('{$event_banner_url}');"
17 | ]);
18 | 


--------------------------------------------------------------------------------
/views/default/event_manager/event/view/contact_details.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event = elgg_extract('entity', $vars);
 4 | if (!$event instanceof \Event) {
 5 | 	return;
 6 | }
 7 | 
 8 | $contact_information = '';
 9 | 
10 | $website = $event->website;
11 | $contact_details = $event->contact_details;
12 | $organizer = $event->organizer;
13 | 
14 | if ($organizer) {
15 | 	$contact_information .= elgg_view_image_block(
16 | 		elgg_view_icon('user', ['title' => elgg_echo('event_manager:edit:form:organizer')]),
17 | 		elgg_view('output/longtext', ['value' => $organizer])
18 | 	);
19 | }
20 | 
21 | if ($contact_details) {
22 | 	$contact_information .= elgg_view_image_block(
23 | 		elgg_view_icon('info-circle', ['title' => elgg_echo('event_manager:edit:form:contact_details')]),
24 | 		elgg_view('output/longtext', ['value' => $contact_details])
25 | 	);
26 | }
27 | 
28 | if ($website) {
29 | 	if (!preg_match('~^https?\://~i', $website)) {
30 | 		$website = "http://{$website}";
31 | 	}
32 | 	
33 | 	$contact_information .= elgg_view_image_block(
34 | 		elgg_view_icon('globe', ['title' => elgg_echo('event_manager:edit:form:website')]),
35 | 		elgg_view_url($website)
36 | 	);
37 | }
38 | 
39 | if (!empty($contact_information)) {
40 | 	echo elgg_view_module('event', elgg_echo('event_manager:edit:form:tabs:contact'), $contact_information, ['class' => 'event-manager-contact-details']);
41 | }
42 | 
43 | $contact_guids = $event->contact_guids;
44 | if (!empty($contact_guids)) {
45 | 	if (!is_array($contact_guids)) {
46 | 		$contact_guids = [$contact_guids];
47 | 	}
48 | 	
49 | 	$contact_content = '';
50 | 	foreach ($contact_guids as $contact_guid) {
51 | 		$member_entity = get_entity($contact_guid);
52 | 		if (empty($member_entity)) {
53 | 			continue;
54 | 		}
55 | 		
56 | 		$member_icon = elgg_view_entity_icon($member_entity, 'tiny', ['event' => $event]);
57 | 		$contact_content .= elgg_view_image_block($member_icon, elgg_view_entity_url($member_entity), ['class' => 'pan']);
58 | 	}
59 | 	
60 | 	echo elgg_view_module('event', elgg_echo('event_manager:event:view:contact_persons'), $contact_content);
61 | }
62 | 


--------------------------------------------------------------------------------
/views/default/event_manager/event/view/datetime.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event = elgg_extract('entity', $vars);
 4 | if (!$event instanceof \Event) {
 5 | 	return;
 6 | }
 7 | 
 8 | $full_format = elgg_echo('event_manager:date:view:full');
 9 | $short_format = elgg_echo('event_manager:date:view:short');
10 | $time_format = elgg_echo('event_manager:date:view:time');
11 | 
12 | // use custom format to convert gmdate to localized
13 | $event_start = \Elgg\Values::normalizeTime($event->getStartDate('d-m-Y H:i:s'));
14 | $event_end = \Elgg\Values::normalizeTime($event->getEndDate('d-m-Y H:i:s'));
15 | 
16 | $when_title = $event_start->formatLocale($short_format);
17 | $when_subtitle = '';
18 | 
19 | if (!$event->isMultiDayEvent()) {
20 | 	// same day event
21 | 	$when_subtitle .= $event_start->formatLocale($time_format) . ' ' . strtolower(elgg_echo('event_manager:date:to')) . ' ' . $event_end->formatLocale($time_format);
22 | } else {
23 | 	$when_title .= ' ' . $event_start->formatLocale($time_format);
24 | 	
25 | 	$when_subtitle .= strtolower(elgg_echo('event_manager:date:to')) . ' ';
26 | 	$when_subtitle .= $event_end->formatLocale($full_format);
27 | }
28 | 
29 | $when = elgg_format_element('div', ['class' => 'event-manager-event-when-title'], $when_title);
30 | if (!empty($when_subtitle)) {
31 | 	$when .= elgg_format_element('div', ['class' => 'event-manager-event-when-subtitle'], $when_subtitle);
32 | }
33 | 
34 | echo elgg_view_image_block(elgg_view_icon('calendar', ['class' => 'elgg-icon-hover']), $when, ['class' => 'event-manager-event-when']);
35 | 


--------------------------------------------------------------------------------
/views/default/event_manager/event/view/description.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event = elgg_extract('entity', $vars);
 4 | if (!$event instanceof \Event) {
 5 | 	return;
 6 | }
 7 | 
 8 | // description
 9 | $description = $event->description ?: $event->shortdescription;
10 | if (empty($description)) {
11 | 	return;
12 | }
13 | 
14 | echo elgg_view_module('event', '', elgg_view('output/longtext', ['value' => $description, 'class' => 'man']));
15 | 


--------------------------------------------------------------------------------
/views/default/event_manager/event/view/files.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event = elgg_extract('entity', $vars);
 4 | if (!$event instanceof \Event) {
 5 | 	return;
 6 | }
 7 | 
 8 | // files
 9 | $event_files = elgg_view_menu('event_files', ['entity' => $event]);
10 | $can_edit = $event->canEdit();
11 | if (empty($event_files) && !$can_edit) {
12 | 	return;
13 | }
14 | 
15 | $module_vars = [];
16 | if ($can_edit) {
17 | 	$module_vars['menu'] = elgg_view('output/url', [
18 | 		'href' => elgg_generate_url('edit:object:event:upload', ['guid' => $event->guid]),
19 | 		'title' => elgg_echo('event_manager:event:uploadfiles'),
20 | 		'text' => elgg_echo('upload'),
21 | 		'icon' => 'plus-circle',
22 | 	]);
23 | }
24 | 
25 | if (empty($event_files)) {
26 | 	$event_files = elgg_echo('event_manager:event:uploadfiles:no_files');
27 | }
28 | 
29 | echo elgg_view_module('info', elgg_echo('event_manager:edit:form:files'), $event_files, $module_vars);
30 | 


--------------------------------------------------------------------------------
/views/default/event_manager/event/view/location.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event = elgg_extract('entity', $vars);
 4 | if (!$event instanceof \Event) {
 5 | 	return;
 6 | }
 7 | 
 8 | $location_details = '';
 9 | 
10 | $event_location = $event->location;
11 | $event_venue = $event->venue;
12 | $event_region = $event->region;
13 | 
14 | if ($event_region) {
15 | 	$location_details .= elgg_view_image_block(
16 | 		elgg_format_element('label', [], elgg_echo('event_manager:edit:form:region') . ':'),
17 | 		$event_region
18 | 	);
19 | }
20 | 
21 | if ($event_venue) {
22 | 	$location_details .= elgg_view_image_block(
23 | 		elgg_format_element('label', [], elgg_echo('event_manager:edit:form:venue') . ':'),
24 | 		$event_venue
25 | 	);
26 | }
27 | 
28 | if ($event_location) {
29 | 	$maps_provider = event_manager_get_maps_provider();
30 | 	
31 | 	$location_details .= elgg_view_image_block(
32 | 		elgg_format_element('label', [], elgg_echo('event_manager:edit:form:location') . ':'),
33 | 		$event_location . elgg_view("event_manager/maps/{$maps_provider}/route", $vars)
34 | 	);
35 | 	
36 | 	$location_details .= elgg_view("event_manager/maps/{$maps_provider}/location", $vars);
37 | }
38 | 
39 | if (empty($location_details)) {
40 | 	return;
41 | }
42 | 
43 | echo elgg_view_module('event', '', $location_details, ['id' => 'location']);
44 | 


--------------------------------------------------------------------------------
/views/default/event_manager/event/view/registration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event = elgg_extract('entity', $vars);
 4 | if (!$event instanceof \Event) {
 5 | 	return;
 6 | }
 7 | 
 8 | $registration_details = '';
 9 | $max_attendees = $event->max_attendees;
10 | $fee = $event->fee;
11 | $type = $event->event_type;
12 | $endregistration_day = $event->endregistration_day;
13 | 
14 | if ($endregistration_day) {
15 | 	$registration_details .= elgg_view_image_block(
16 | 		elgg_format_element('label', [], elgg_echo('event_manager:edit:form:endregistration_day') . ':'),
17 | 		elgg_view('output/date', ['value' => $endregistration_day])
18 | 	);
19 | }
20 | 
21 | if ($max_attendees) {
22 | 	$attendee_info = '';
23 | 	
24 | 	$spots_left = ($max_attendees - $event->countAttendees());
25 | 	if ($spots_left < 1) {
26 | 		$count_waitinglist = $event->countWaiters();
27 | 		if ($count_waitinglist > 0) {
28 | 			$attendee_info .= elgg_echo('event_manager:full') . ', ' . $count_waitinglist . ' ';
29 | 			if ($count_waitinglist == 1) {
30 | 				$attendee_info .= elgg_echo('event_manager:personwaitinglist');
31 | 			} else {
32 | 				$attendee_info .= elgg_echo('event_manager:peoplewaitinglist');
33 | 			}
34 | 		} else {
35 | 			$attendee_info .= elgg_echo('event_manager:full');
36 | 		}
37 | 	} else {
38 | 		$attendee_info .= $spots_left . ' / ' . $max_attendees;
39 | 	}
40 | 	
41 | 	$registration_details .= elgg_view_image_block(
42 | 		elgg_format_element('label', [], elgg_echo('event_manager:edit:form:spots_left') . ':'),
43 | 		$attendee_info
44 | 	);
45 | }
46 | 
47 | if ($fee) {
48 | 	$registration_details .= elgg_view_image_block(
49 | 		elgg_format_element('label', [], elgg_echo('event_manager:edit:form:fee') . ':'),
50 | 		elgg_view('output/text', ['value' => $fee]) . elgg_view('output/longtext', ['value' => $event->fee_details])
51 | 	);
52 | }
53 | 
54 | if ($type) {
55 | 	$registration_details .= elgg_view_image_block(
56 | 		elgg_format_element('label', [], elgg_echo('event_manager:edit:form:type') . ':'),
57 | 		$type
58 | 	);
59 | }
60 | 
61 | $content = elgg_format_element('div', [], $registration_details);
62 | $content .= elgg_format_element('div', [], elgg_view('event_manager/event/rsvp', $vars));
63 | 
64 | echo elgg_format_element('div', ['class' => 'event-manager-view-registration-details'], $content);
65 | 


--------------------------------------------------------------------------------
/views/default/event_manager/forms/program/day.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event_guid = (int) get_input('event_guid');
 4 | $day_guid = (int) get_input('day_guid');
 5 | 
 6 | $event = get_entity($event_guid);
 7 | $day = elgg_call(ELGG_IGNORE_ACCESS, function() use ($day_guid) {
 8 | 	// days are unavailable if event is private
 9 | 	return get_entity($day_guid);
10 | });
11 | 
12 | if ($event instanceof \Event) {
13 | 	$entity = $event;
14 | } elseif ($day instanceof \ColdTrick\EventManager\Event\Day) {
15 | 	// assume day edit mode
16 | 	$entity = $day;
17 | }
18 | 
19 | if (!$entity || !$entity->canEdit()) {
20 | 	echo elgg_echo('EntityPermissionsException');
21 | 	return;
22 | }
23 | 
24 | $guid = null;
25 | $description = null;
26 | $title = null;
27 | 
28 | if ($entity instanceof \ColdTrick\EventManager\Event\Day) {
29 | 	// assume day edit mode
30 | 	$guid = $entity->guid;
31 | 	$parent_guid = $entity->owner_guid;
32 | 	$title = $entity->title;
33 | 	$description = $entity->description;
34 | 	$date = $entity->date;
35 | } else {
36 | 	// entity is a event
37 | 	$parent_guid = $entity->guid;
38 | 
39 | 	// make nice default date
40 | 	$days = $entity->getEventDays();
41 | 	$last_day = end($days);
42 | 	if (!$last_day) {
43 | 		$date = $entity->getStartTimestamp() + (3600 * 24);
44 | 	} else {
45 | 		$date = $last_day->date + (3600 * 24);
46 | 	}
47 | }
48 | 
49 | $form_body = elgg_view_field([
50 | 	'#type' => 'date',
51 | 	'#label' => elgg_echo('event_manager:edit:form:start_day'),
52 | 	'name' => 'date',
53 | 	'id' => 'date',
54 | 	'timestamp' => true,
55 | 	'value' => $date,
56 | 	'required' => true,
57 | ]);
58 | 
59 | $form_body .= elgg_view_field([
60 | 	'#type' => 'text',
61 | 	'#label' => elgg_echo('title'),
62 | 	'name' => 'description',
63 | 	'value' => $description
64 | ]);
65 | 
66 | $form_body .= elgg_view_field([
67 | 	'#type' => 'text',
68 | 	'#label' => elgg_echo('description'),
69 | 	'name' => 'title',
70 | 	'value' => $title,
71 | ]);
72 | 
73 | $form_body .= elgg_view_field([
74 | 	'#type' => 'submit',
75 | 	'text' => elgg_echo('submit'),
76 | 	'class' => 'mtm',
77 | ]);
78 | $form_body .= elgg_view_field([
79 | 	'#type' => 'hidden',
80 | 	'name' => 'guid',
81 | 	'value' => $guid
82 | ]);
83 | $form_body .= elgg_view_field([
84 | 	'#type' => 'hidden',
85 | 	'name' => 'parent_guid',
86 | 	'value' => $parent_guid
87 | ]);
88 | 
89 | $body = elgg_view('input/form', [
90 | 	'id' => 'event_manager_form_program_day',
91 | 	'name' => 'event_manager_form_program_day',
92 | 	'action' => false,
93 | 	'body' => $form_body,
94 | ]);
95 | 
96 | echo elgg_view_module('info', elgg_echo('event_manager:form:program:day'), $body, ['id' => 'event-manager-program-day-lightbox']);
97 | 


--------------------------------------------------------------------------------
/views/default/event_manager/listing/calendar.mjs.php:
--------------------------------------------------------------------------------
 1 | <?php ?>
 2 | import 'jquery';
 3 | import 'elgg';
 4 | import lightbox from 'elgg/lightbox';
 5 | 
 6 | <?php echo elgg_view('fullcalendar.js'); ?>
 7 | 
 8 | var calendarEl = document.getElementById('event-manager-event-calendar');
 9 | var wrapper_data = $('#event-manager-event-calendar-wrapper').data();
10 | var events_url = 'event_manager/calendar?' + $.param(wrapper_data);
11 | 
12 | var calendar = new FullCalendar.Calendar(calendarEl, {
13 | 	events: elgg.normalize_url(events_url),
14 | 	headerToolbar: {
15 | 		left: 'prev next today',
16 | 		center: 'title',
17 | 		right: 'dayGridMonth timeGridWeek timeGridDay'
18 | 	},
19 | 	views: {
20 | 		dayGridMonth: {
21 | 			dayMaxEventRows: 5
22 | 		}
23 | 	},
24 | 	eventTimeFormat: { // like '14:30'
25 | 		hour: 'numeric',
26 | 		minute: '2-digit',
27 | 		meridiem: false
28 | 	},
29 | 	defaultAllDay: true,
30 | 	locale: elgg.config.current_language,
31 | 	timeZone: 'UTC',
32 | 	eventClick: function (info) {
33 | 		var guid = info.event.extendedProps.guid;
34 | 		if (!guid) {
35 | 			return;
36 | 		}
37 | 		
38 | 		lightbox.open({
39 | 			'href': elgg.normalize_url('ajax/view/event_manager/event/popup?guid=' + guid),
40 | 		});
41 | 		
42 | 		info.jsEvent.preventDefault(); // don't let the browser navigate
43 | 	}
44 | });
45 | 
46 | calendar.render();
47 | 


--------------------------------------------------------------------------------
/views/default/event_manager/listing/calendar.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Calendar listing of events used by resource files
 4 |  *
 5 |  * @uses $vars['options']    Additional options for elgg_list_entities()
 6 |  * @uses $vars['resource']   The calling resource
 7 |  * @uses $vars['page_owner'] Page owner during the call
 8 |  */
 9 | 
10 | elgg_import_esm('event_manager/listing/calendar');
11 | 
12 | $page_owner = elgg_extract('page_owner', $vars);
13 | 
14 | $wrapper_attr = [
15 | 	'id' => 'event-manager-event-calendar-wrapper',
16 | 	'data-resource' => elgg_extract('resource', $vars),
17 | 	'data-guid' => ($page_owner instanceof ElggEntity) ? $page_owner->guid : null,
18 | 	'data-tag' => get_input('tag'),
19 | ];
20 | $content = elgg_format_element('div', ['id' => 'event-manager-event-calendar']);
21 | 
22 | echo elgg_view('event_manager/listing/elements/tags');
23 | 
24 | echo elgg_format_element('div', $wrapper_attr, $content);
25 | 


--------------------------------------------------------------------------------
/views/default/event_manager/listing/elements/tags.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $tag = get_input('tag');
 4 | if (empty($tag)) {
 5 | 	return;
 6 | }
 7 | 
 8 | $tag_link = elgg_view('output/url', [
 9 | 	'href' => elgg_http_add_url_query_elements(elgg_get_current_url(), ['tag' => null]),
10 | 	'text' => $tag,
11 | 	'icon_alt' => 'remove',
12 | ]);
13 | 
14 | echo elgg_format_element('div', ['class' => 'event-manager-listing-tags mbm'], elgg_echo('event_manager:list:filter:tags', [$tag_link]));
15 | 


--------------------------------------------------------------------------------
/views/default/event_manager/listing/list.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Default Elgg listing of events used by resource files
 4 |  *
 5 |  * @uses $vars['options'] Additional options for elgg_list_entities()
 6 |  */
 7 | 
 8 | $options = (array) elgg_extract('options', $vars, []);
 9 | 
10 | $defaults = [
11 | 	'type' => 'object',
12 | 	'subtype' => \Event::SUBTYPE,
13 | 	'no_results' => elgg_echo('event_manager:list:noresults'),
14 | ];
15 | 
16 | $options = array_merge($defaults, $options);
17 | 
18 | $tag = get_input('tag');
19 | if (!empty($tag)) {
20 | 	echo elgg_view('event_manager/listing/elements/tags');
21 | 	
22 | 	$options['metadata_name_value_pairs'][] = [
23 | 		'name' => 'tags',
24 | 		'value' => $tag,
25 | 		'case_sensitive' => false,
26 | 	];
27 | }
28 | 
29 | echo elgg_list_entities($options);
30 | 


--------------------------------------------------------------------------------
/views/default/event_manager/listing/map.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Map listing of events used by resource files
 4 |  *
 5 |  * @uses $vars['options']    Additional options for elgg_list_entities()
 6 |  * @uses $vars['resource']   The calling resource
 7 |  * @uses $vars['page_owner'] Page owner during the call
 8 |  */
 9 | 
10 | use Elgg\Exceptions\Http\EntityNotFoundException;
11 | 
12 | $maps_provider = event_manager_get_maps_provider();
13 | if ($maps_provider === 'none') {
14 | 	throw new EntityNotFoundException();
15 | }
16 | 
17 | $page_owner = elgg_extract('page_owner', $vars);
18 | 
19 | $body = elgg_format_element('div', [
20 | 	'id' => 'event_manager_onthemap_canvas',
21 | 	'data-resource' => elgg_extract('resource', $vars),
22 | 	'data-guid' => ($page_owner instanceof \ElggEntity) ? $page_owner->guid : null,
23 | 	'data-tag' => get_input('tag'),
24 | ]);
25 | 
26 | echo elgg_view('event_manager/listing/elements/tags');
27 | 
28 | echo elgg_format_element('div', ['id' => 'event_manager_event_map'], $body);
29 | 
30 | ?>
31 | <script type='module'>
32 | 	import 'event_manager/maps/<?php echo $maps_provider; ?>/onthemap';
33 | 	import hooks from 'elgg/hooks';
34 | 	
35 | 	hooks.trigger('tab:onthemap', 'event_manager');
36 | </script>
37 | 


--------------------------------------------------------------------------------
/views/default/event_manager/maps/osm/location.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $entity = elgg_extract('entity', $vars);
 4 | if (!$entity instanceof \Event) {
 5 | 	return;
 6 | }
 7 | 
 8 | $lat = $entity->getLatitude();
 9 | $long = $entity->getLongitude();
10 | 
11 | if (empty($lat) || empty($long)) {
12 | 	return;
13 | }
14 | 
15 | elgg_load_external_file('css', 'leafletjs');
16 | 
17 | echo elgg_format_element('div', [
18 | 	'id' => 'event-manager-leafletjs-map',
19 | 	'class' => 'event-manager-event-view-maps',
20 | ]);
21 | 
22 | $event_zoom_level = (int) elgg_get_plugin_setting('osm_detail_zoom', 'event_manager', 12);
23 | 
24 | ?>
25 | <script type='module'>
26 | 	import EventMap from 'event_manager/maps/osm/osm';
27 | 	
28 | 	EventMap.setup({
29 | 		element: 'event-manager-leafletjs-map',
30 | 		lat: <?php echo $lat; ?>,
31 | 		lng: <?php echo $long; ?>,
32 | 		zoom: <?php echo $event_zoom_level; ?>,
33 | 	}).addMarker({
34 | 		lat: <?php echo $lat; ?>,
35 | 		lng: <?php echo $long; ?>
36 | 	});
37 | </script>
38 | 


--------------------------------------------------------------------------------
/views/default/event_manager/maps/osm/location_input.mjs:
--------------------------------------------------------------------------------
  1 | import 'jquery';
  2 | import lightbox from 'elgg/lightbox';
  3 | import EventMap from 'event_manager/maps/osm/osm';
  4 | 
  5 | var event_map;
  6 | var location_data;
  7 | 
  8 | var createAddress = function(addressData) {
  9 | 	
 10 | 	var address = addressData.road;
 11 | 	if (addressData.house_number) {
 12 | 		address += ' ' + addressData.house_number;
 13 | 	}
 14 | 	
 15 | 	if (addressData.city) {
 16 | 		address += ', ' + addressData.city;
 17 | 	} else if (addressData.town) {
 18 | 		address += ', ' + addressData.town;
 19 | 	} else if (addressData.suburb) {
 20 | 		address += ', ' + addressData.suburb;
 21 | 	}
 22 | 	
 23 | 	address += ', ' + addressData.country;
 24 | 	
 25 | 	return address;
 26 | };
 27 | 
 28 | var executeSearch = function() {
 29 | 	var $search_form = $('#event-manager-edit-maps-search-container');
 30 | 	
 31 | 	event_map.clearMarkers();
 32 | 	
 33 | 	event_map.getGeocode($search_form.find('input[name="address_search"]').val(), function(result) {
 34 | 		location_data = result;
 35 | 		
 36 | 		$('#event-manager-edit-maps-search-container input[name="address_search"]').val(createAddress(location_data.address));
 37 | 		
 38 | 		$search_form.find('[name="address_search_save"]').removeClass('hidden');
 39 | 		
 40 | 		event_map.moveToLatLng(location_data.lat, location_data.lon, true);
 41 | 	});
 42 | };
 43 | 
 44 | $('#event_manager_event_edit input[name="location"]').on('focus', function() {
 45 | 	var $elem = $(this);
 46 | 	
 47 | 	lightbox.open({
 48 | 		'inline': true,
 49 | 		'href': '#event-manager-edit-maps-search-container',
 50 | 		'onComplete': function () {
 51 | 			
 52 | 			var current_location = $elem.val();
 53 | 			var $container = $('#event-manager-edit-maps-search-container');
 54 | 			if (current_location) {
 55 | 				$container.find('input[name="address_search"]').val(current_location);
 56 | 				$container.find('[name="address_search_save"]').removeClass('hidden');
 57 | 			}
 58 | 			
 59 | 			$container.find('input[name="address_search"]').focus();
 60 | 			
 61 | 			import('leafletjs').then((leaflet) => {
 62 | 				if (!event_map) {
 63 | 					var lat = $('#event_manager_event_edit input[name="latitude"]').val();
 64 | 					var lng = $('#event_manager_event_edit input[name="longitude"]').val();
 65 | 					
 66 | 					event_map = EventMap.setup({
 67 | 						element: 'event-manager-maps-location-search'
 68 | 					});
 69 | 					if (lat && lng) {
 70 | 						event_map.moveToLatLng(lat, lng, true);
 71 | 					} else {
 72 | 						event_map.moveToDefaultLocation();
 73 | 					}
 74 | 				}
 75 | 			});
 76 | 		}
 77 | 	});
 78 | });
 79 | 
 80 | $(document).on('keyup', '#event-manager-edit-maps-search-container input[name="address_search"]', function(event) {
 81 | 	if (event.keyCode == 13) {
 82 | 		executeSearch();
 83 | 	} else {
 84 | 		$('#event-manager-edit-maps-search-container [name="address_search_save"]').addClass('hidden');
 85 | 	}
 86 | });
 87 | $(document).on('click', '#event-manager-edit-maps-search-container button[name="address_search_submit"]', function() {
 88 | 	executeSearch();
 89 | });
 90 | 
 91 | $(document).on('click', '#event-manager-edit-maps-search-container button[name="address_search_save"]', function() {
 92 | 	var address = $('#event-manager-edit-maps-search-container input[name="address_search"]').val();
 93 | 	var $location_field = $('#event_manager_event_edit input[name="location"]');
 94 | 	var $latitude = $('#event_manager_event_edit input[name="latitude"]');
 95 | 	var $longitude = $('#event_manager_event_edit input[name="longitude"]');
 96 | 
 97 | 	if (location_data) {
 98 | 		$location_field.val(createAddress(location_data.address));
 99 | 
100 | 		$latitude.val(location_data.lat);
101 | 		$longitude.val(location_data.lon);
102 | 		
103 | 		$('#event-manager-location-input-delete').closest('.elgg-field').removeClass('hidden');
104 | 	} else {
105 | 		$location_field.val('');
106 | 		$latitude.val('');
107 | 		$longitude.val('');
108 | 	}
109 | 	
110 | 	lightbox.close();
111 | });
112 | 


--------------------------------------------------------------------------------
/views/default/event_manager/maps/osm/location_input.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | elgg_import_esm('event_manager/maps/osm/location_input');
4 | elgg_load_external_file('css', 'leafletjs');
5 | 
6 | $field_options = (array) elgg_extract('field_options', $vars);
7 | 
8 | echo elgg_view_field($field_options);
9 | 


--------------------------------------------------------------------------------
/views/default/event_manager/maps/osm/onthemap.mjs:
--------------------------------------------------------------------------------
  1 | import 'jquery';
  2 | import 'elgg';
  3 | import hooks from 'elgg/hooks';
  4 | import Ajax from 'elgg/Ajax';
  5 | import lightbox from 'elgg/lightbox';
  6 | 
  7 | var event_map;
  8 | var current_markers = [];
  9 | 
 10 | var execute_search_map = function(event) {
 11 | 	if (!event_map) {
 12 | 		return;
 13 | 	}
 14 | 	
 15 | 	var ajax = new Ajax();
 16 | 	
 17 | 	var mapBounds = event_map.getMap().getBounds();
 18 | 	var latitude = mapBounds.getCenter().lat;
 19 | 	var longitude = mapBounds.getCenter().lng;
 20 | 	var distance_latitude = mapBounds.getNorthEast().lat - latitude;
 21 | 	var distance_longitude = mapBounds.getNorthEast().lng - longitude;
 22 | 	if (distance_longitude < 0) {
 23 | 		distance_longitude = 360 + distance_longitude;
 24 | 	}
 25 | 	
 26 | 	var canvas_data = $('#event_manager_onthemap_canvas').data();
 27 | 	
 28 | 	ajax.action('event_manager/maps/data', {
 29 | 		data: {
 30 | 			...canvas_data,
 31 | 			latitude: latitude,
 32 | 			longitude: longitude,
 33 | 			distance_latitude: distance_latitude,
 34 | 			distance_longitude: distance_longitude
 35 | 		},
 36 | 		success: function(data) {
 37 | 			if (!data.markers) {
 38 | 				return;
 39 | 			}
 40 | 			
 41 | 			$.each(data.markers, function(i, event) {
 42 | 				if (current_markers[event.guid]) {
 43 | 					// already added, so return
 44 | 					return;
 45 | 				}
 46 | 				
 47 | 				var custom_icon_options = {
 48 | 					iconUrl: 'https://raw.githubusercontent.com/pointhi/leaflet-color-markers/master/img/marker-icon-red.png',
 49 | 					shadowUrl: 'https://cdnjs.cloudflare.com/ajax/libs/leaflet/0.7.7/images/marker-shadow.png',
 50 | 					iconSize: [25, 41],
 51 | 					iconAnchor: [12, 41],
 52 | 					popupAnchor: [1, -34],
 53 | 					shadowSize: [41, 41],
 54 | 					...elgg.data.event_manager_osm_icon_default
 55 | 				}
 56 | 				
 57 | 				if (event.iscreator) {
 58 | 					custom_icon_options = {
 59 | 						...custom_icon_options,
 60 | 						...{
 61 | 							iconUrl: 'https://raw.githubusercontent.com/pointhi/leaflet-color-markers/master/img/marker-icon-yellow.png'
 62 | 						},
 63 | 						...elgg.data.event_manager_osm_icon_owned
 64 | 					}
 65 | 				} else {
 66 | 					if (event.has_relation) {
 67 | 						custom_icon_options = {
 68 | 							...custom_icon_options,
 69 | 							...{
 70 | 								iconUrl: 'https://raw.githubusercontent.com/pointhi/leaflet-color-markers/master/img/marker-icon-blue.png'
 71 | 							},
 72 | 							...elgg.data.event_manager_osm_icon_attending
 73 | 						}
 74 | 					}
 75 | 				}
 76 | 
 77 | 				var markerOptions = {
 78 | 					lat: event.lat,
 79 | 					lng: event.lng,
 80 | 					icon: custom_icon_options
 81 | 				};
 82 | 				
 83 | 				var marker = event_map.addMarker(markerOptions).on('click', function() {
 84 | 					lightbox.open({
 85 | 						'href': elgg.normalize_url('ajax/view/event_manager/event/popup?guid=' + event.guid),
 86 | 					});
 87 | 				});
 88 | 				
 89 | 				current_markers[event.guid] = true;
 90 | 			});
 91 | 		}
 92 | 	});
 93 | };
 94 | 
 95 | var initialize_tab = function() {
 96 | 	if (typeof event_map === 'undefined') {
 97 | 		import('event_manager/maps/osm/osm').then((EventMap) => {
 98 | 			event_map = EventMap.default.setup({
 99 | 				element: 'event_manager_onthemap_canvas'
100 | 			});
101 | 			event_map.moveToDefaultLocation();
102 | 			event_map.getMap().on('moveend', execute_search_map);
103 | 			execute_search_map();
104 | 		});
105 | 	} else {
106 | 		execute_search_map();
107 | 	}
108 | };
109 | 
110 | initialize_tab();
111 | 
112 | hooks.register('search:onthemap', 'event_manager', execute_search_map);
113 | 


--------------------------------------------------------------------------------
/views/default/event_manager/maps/osm/osm.mjs:
--------------------------------------------------------------------------------
 1 | import 'jquery';
 2 | import 'elgg';
 3 | import 'leafletjs';
 4 | 
 5 | function EventMap(options) {
 6 | 	this.event_map = leaflet.map(options.element, options);
 7 | 
 8 | 	// create the tile layer with correct attribution
 9 | 	var osmUrl = '//{s}.tile.openstreetmap.org/{z}/{x}/{y}.png';
10 | 	var osmAttrib = 'Map data © <a href="http://openstreetmap.org">OpenStreetMap</a> contributors';
11 | 	
12 | 	var osm = new leaflet.TileLayer(osmUrl, {
13 | 		attribution: osmAttrib
14 | 	});
15 | 
16 | 	this.event_map.addLayer(osm);
17 | 	
18 | 	// add marker group
19 | 	this.markerGroup = leaflet.layerGroup().addTo(this.event_map);
20 | };
21 | 
22 | EventMap.prototype = {
23 | 	moveToLatLng: function(lat, lng, add_marker) {
24 | 		this.event_map.setView([lat, lng]);
25 | 
26 | 		if (add_marker == true) {
27 | 			this.addMarker([lat, lng]);
28 | 		}
29 | 		
30 | 	},
31 | 	moveToDefaultLocation: function() {
32 | 		this.event_map.setView([elgg.data.event_manager_osm_default_location_lat, elgg.data.event_manager_osm_default_location_lng]);
33 | 	},
34 | 	getGeocode: function(address, callback) {
35 | 		$.getJSON('https://nominatim.openstreetmap.org/search?q=' + address + '&format=json&limit=1&addressdetails=1', function(data) {
36 | 			callback(data[0]);
37 | 		});
38 | 		this.event_map.attributionControl.addAttribution('© <a href="https://nominatim.openstreetmap.org">Nominatim</a>');
39 | 	},
40 | 	addMarker: function(options) {
41 | 		var extra_options = {};
42 | 		if (options.icon) {
43 | 			extra_options['icon'] = new leaflet.Icon(options.icon);
44 | 		}
45 | 
46 | 		return leaflet.marker(options, extra_options).addTo(this.markerGroup);
47 | 	},
48 | 	clearMarkers: function() {
49 | 		this.markerGroup.clearLayers();
50 | 	},
51 | 	getMap: function() {
52 | 		return this.event_map;
53 | 	}
54 | };
55 | 
56 | EventMap.setup = function(options) {
57 | 	if (!options) {
58 | 		options = {};
59 | 	}
60 | 
61 | 	if (!options.zoom) {
62 | 		options.zoom = elgg.data.event_manager_osm_default_zoom;
63 | 	}
64 | 	
65 | 	if (!options.element) {
66 | 		if (window.console) {
67 | 			console.log('Missing element to initialize map');
68 | 		}
69 | 		
70 | 		return false;
71 | 	}
72 | 	
73 | 	var map = new EventMap(options);
74 | 	if (options.lat && options.lng) {
75 | 		map.moveToLatLng(options.lat, options.lng);
76 | 	}
77 | 
78 | 	return map;
79 | };
80 | 
81 | export default EventMap;
82 | 


--------------------------------------------------------------------------------
/views/default/event_manager/maps/osm/route.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $entity = elgg_extract('entity', $vars);
 4 | if (!$entity instanceof \Event) {
 5 | 	return;
 6 | }
 7 | 
 8 | if (empty($entity->getLatitude()) || empty($entity->getLongitude())) {
 9 | 	return;
10 | }
11 | 
12 | echo elgg_view('output/url', [
13 | 	'href' => 'www.openstreetmap.org/directions?engine=osrm_car&route=%3B' . $entity->getLatitude() . '%2C' . $entity->getLongitude(),
14 | 	'text' => elgg_echo('event_manager:event:location:plan_route'),
15 | 	'target' => '_blank',
16 | 	'class' => 'mlm',
17 | ]);
18 | 


--------------------------------------------------------------------------------
/views/default/event_manager/program/edit.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | // @todo merge this view with the event_manager/program/view view
 3 | 
 4 | $event = elgg_extract('entity', $vars);
 5 | $register_type = elgg_extract('register_type', $vars);
 6 | 
 7 | if (!$event instanceof \Event) {
 8 | 	return;
 9 | }
10 | 
11 | if (!$event->with_program) {
12 | 	return;
13 | }
14 | 
15 | $tab_options = [
16 | 	'id' => 'event_manager_event_view_program',
17 | 	'tabs' => [],
18 | ];
19 | 
20 | $eventDays = $event->getEventDays();
21 | foreach ($eventDays as $key => $day) {
22 | 	$tab_options['tabs'][] = [
23 | 		'text' => $day->description ?: event_manager_format_date($day->date),
24 | 		'content' => elgg_view('event_manager/program/elements/day', [
25 | 			'entity' => $day,
26 | 			'participate' => true,
27 | 			'register_type' => $register_type,
28 | 		]),
29 | 		'selected' => ($key === 0),
30 | 	];
31 | }
32 | 
33 | $program = elgg_view('input/hidden', [
34 | 	'id' => 'event_manager_program_guids',
35 | 	'name' => 'program_guids'
36 | ]);
37 | 
38 | $program .= elgg_view('page/components/tabs', $tab_options);
39 | 
40 | $slot_sets = elgg_get_metadata([
41 | 	'type' => 'object',
42 | 	'subtype' => \ColdTrick\EventManager\Event\Slot::SUBTYPE,
43 | 	'container_guids' => [$event->guid],
44 | 	'metadata_names' => ['slot_set'],
45 | 	'count' => true,
46 | ]);
47 | 
48 | if ($slot_sets > 0) {
49 | 	$program .= elgg_format_element('span', ['class' => 'elgg-subtext'], elgg_echo('event_manager:registration:slot_set:info'));
50 | }
51 | 
52 | echo elgg_view_module('info', elgg_echo('event_manager:event:program'), $program);
53 | 


--------------------------------------------------------------------------------
/views/default/event_manager/program/elements/day.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $day = elgg_extract('entity', $vars);
 4 | $participate = elgg_extract('participate', $vars);
 5 | $register_type = elgg_extract('register_type', $vars);
 6 | $details_only = elgg_extract('details_only', $vars);
 7 | $show_owner_actions = elgg_extract('show_owner_actions', $vars, true);
 8 | 
 9 | if (!$day instanceof \ColdTrick\EventManager\Event\Day) {
10 | 	return;
11 | }
12 | 
13 | $can_edit = $day->canEdit();
14 | 
15 | $details = '';
16 | if ($day->description) {
17 | 	$details .= '<div><b>' . elgg_echo('event_manager:edit:form:start_day') . ':</b> ' . event_manager_format_date($day->date) . '</div>';
18 | }
19 | 
20 | $details .= $day->getDisplayName();
21 | 
22 | if ($can_edit && $show_owner_actions && ($participate == false)) {
23 | 	$edit_day = elgg_view('output/url', [
24 | 		'href' => false,
25 | 		'rel' => $day->guid,
26 | 		'data-colorbox-opts' => json_encode([
27 | 			'href' => elgg_normalize_url('ajax/view/event_manager/forms/program/day?day_guid=' . $day->guid)
28 | 		]),
29 | 		'class' => 'event_manager_program_day_edit elgg-lightbox',
30 | 		'text' => elgg_echo('edit'),
31 | 	]);
32 | 
33 | 	$delete_day = elgg_view('output/url', [
34 | 		'href' => false,
35 | 		'class' => 'event_manager_program_day_delete',
36 | 		'text' => elgg_echo('delete'),
37 | 	]);
38 | 	
39 | 	$details .= " [ $edit_day | $delete_day ]";
40 | }
41 | 
42 | if ($details_only) {
43 | 	echo $details;
44 | 	return;
45 | }
46 | 
47 | $day_info = elgg_format_element('div', [
48 | 	'class' => 'event_manager_program_day_details pbs mbs elgg-divide-bottom',
49 | 	'rel' => $day->guid,
50 | ], $details);
51 | 
52 | $slots = '';
53 | $daySlots = $day->getEventSlots();
54 | if ($daySlots) {
55 | 	$member = elgg_extract('member', $vars);
56 | 	
57 | 	foreach ($daySlots as $slot) {
58 | 		$slots .= elgg_view('event_manager/program/elements/slot', [
59 | 			'entity' => $slot,
60 | 			'participate' => $participate,
61 | 			'show_owner_actions' => $show_owner_actions,
62 | 			'register_type' => $register_type,
63 | 			'member' => $member,
64 | 		]);
65 | 	}
66 | }
67 | 
68 | if ($can_edit && $show_owner_actions && ($participate == false)) {
69 | 	$slots .= elgg_view('output/url', [
70 | 		'href' => false,
71 | 		'class' => 'elgg-button elgg-button-action event_manager_program_slot_add mll elgg-lightbox',
72 | 		'rel' => $day->guid,
73 | 		'data-colorbox-opts' => json_encode([
74 | 			'href' => elgg_normalize_url('ajax/view/event_manager/forms/program/slot?day_guid=' . $day->guid)
75 | 		]),
76 | 		'text' => elgg_echo('event_manager:program:slot:add'),
77 | 		'icon' => 'plus',
78 | 	]);
79 | }
80 | 
81 | echo elgg_format_element('div', [
82 | 	'class' => ['event_manager_program_day'],
83 | 	'id' => 'day_' . $day->guid
84 | ], $day_info . $slots);
85 | 


--------------------------------------------------------------------------------
/views/default/event_manager/program/pdf.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event = elgg_extract('entity', $vars);
 4 | if (!$event instanceof \Event) {
 5 | 	return;
 6 | }
 7 | 
 8 | if (!$event->with_program) {
 9 | 	return;
10 | }
11 | 
12 | $eventDays = $event->getEventDays();
13 | if (empty($eventDays)) {
14 | 	return;
15 | }
16 | 
17 | echo elgg_format_element('h3', [], elgg_echo('event_manager:event:program'));
18 | 
19 | foreach ($eventDays as $day) {
20 | 	echo elgg_view('event_manager/program/pdf/day', [
21 | 		'entity' => $day,
22 | 		'user_guid' => elgg_extract('user_guid', $vars),
23 | 	]);
24 | }
25 | 


--------------------------------------------------------------------------------
/views/default/event_manager/program/pdf/day.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $day = elgg_extract('entity', $vars);
 4 | $register_type = elgg_extract('register_type', $vars);
 5 | 
 6 | if (!$day instanceof \ColdTrick\EventManager\Event\Day) {
 7 | 	return;
 8 | }
 9 | 
10 | $slots = '';
11 | foreach ($day->getEventSlots() as $slot) {
12 | 	$slots .= elgg_view('event_manager/program/pdf/slot', [
13 | 		'entity' => $slot,
14 | 		'register_type' => $register_type,
15 | 		'user_guid' => elgg_extract('user_guid', $vars),
16 | 	]);
17 | }
18 | 
19 | if (empty($slots)) {
20 | 	return;
21 | }
22 | 	
23 | $title = event_manager_format_date($day->date);
24 | $description = $day->description;
25 | 
26 | if ($description) {
27 | 	$title = "{$description} ({$title})";
28 | }
29 | 
30 | $result = elgg_format_element('div', [], $title);
31 | if ($day->getDisplayName()) {
32 | 	$result .= elgg_format_element('div', [], $day->getDisplayName());
33 | }
34 | 
35 | $result .= "<br /><br />{$slots}<br /><br />";
36 | 
37 | echo $result;
38 | 


--------------------------------------------------------------------------------
/views/default/event_manager/program/pdf/slot.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $slot = elgg_extract('entity', $vars);
 4 | if (!$slot instanceof \ColdTrick\EventManager\Event\Slot) {
 5 | 	return;
 6 | }
 7 | 
 8 | $user_guid = (int) elgg_extract('user_guid', $vars, elgg_get_logged_in_user_guid());
 9 | $user = get_entity($user_guid);
10 | if (!$user instanceof \ElggEntity) {
11 | 	return;
12 | }
13 | 
14 | if (!$user->hasRelationship($slot->guid, EVENT_MANAGER_RELATION_SLOT_REGISTRATION)) {
15 | 	return;
16 | }
17 | 
18 | $start_time = $slot->start_time;
19 | $end_time = $slot->end_time;
20 | 
21 | $result = "<table><tr><td style='padding-left: 10px; vertical-align: top'>";
22 | $result .= date('H:i', $start_time) . ' - ' . date('H:i', $end_time);
23 | $result .= '</td><td>';
24 | $result .= elgg_format_element('b', [], $slot->getDisplayName());
25 | 
26 | if ($slot->location) {
27 | 	$result .= elgg_format_element('div', [], $slot->location);
28 | }
29 | 
30 | $result .= elgg_format_element('div', [], elgg_view('output/text', ['value' => $slot->description]));
31 | 
32 | $result .= '</td></tr></table>';
33 | 
34 | echo $result;
35 | 


--------------------------------------------------------------------------------
/views/default/event_manager/program/view.mjs:
--------------------------------------------------------------------------------
  1 | import 'jquery';
  2 | import i18n from 'elgg/i18n';
  3 | import Ajax from 'elgg/Ajax';
  4 | import lightbox from 'elgg/lightbox';
  5 | 
  6 | var ajax = new Ajax();
  7 | 
  8 | function addSlot(event) {
  9 | 	event.preventDefault();
 10 | 
 11 | 	var $button = $(this).find("input[type='submit']");
 12 | 
 13 | 	// Prevent accidental double click
 14 | 	$button.hide();
 15 | 
 16 | 	var url = $(this).attr('action');
 17 | 
 18 | 	ajax.action(url, {
 19 | 		data: ajax.objectify($(this)),
 20 | 		success: function(output) {
 21 | 			lightbox.close();
 22 | 
 23 | 			if (output.edit) {
 24 | 				$("#" + output.guid).replaceWith(output.content);
 25 | 			} else {
 26 | 				$("#day_" + output.parent_guid).find(".event_manager_program_slot_add").before(output.content);
 27 | 			}
 28 | 		},
 29 | 		error: function () {
 30 | 			$button.show();
 31 | 		}
 32 | 	});
 33 | }
 34 | 
 35 | function addDay(event) {
 36 | 	event.preventDefault();
 37 | 	
 38 | 	var $button = $(this).find("input[type='submit']");
 39 | 	$button.hide();
 40 | 
 41 | 	ajax.action('event_manager/day/edit', {
 42 | 		data: ajax.objectify($(this)),
 43 | 		success: function(output) {
 44 | 			var guid = output.guid;
 45 | 			if (guid) {
 46 | 				lightbox.close();
 47 | 
 48 | 				if (output.edit) {
 49 | 					$("#day_" + guid + " .event_manager_program_day_details").html(output.content_body);
 50 | 					$("#event_manager_event_view_program a[rel='day_" + guid + "']").html(output.content_title).click();
 51 | 				} else {
 52 | 					var $program = $('#event_manager_event_view_program');
 53 | 					$program.find('.elgg-tabs-content').append(output.content_body);
 54 | 					$program.find('.elgg-menu-navigation-tabs').append(output.content_title);
 55 | 					$program.find("a[rel='day_" + guid + "']").click();
 56 | 				}
 57 | 			} else {
 58 | 				$button.show();
 59 | 			}
 60 | 		},
 61 | 		error: function() {
 62 | 			$button.show();
 63 | 		}
 64 | 	});
 65 | }
 66 | 
 67 | $(document).on('click', '.event_manager_program_day_delete', function() {
 68 | 	if (!confirm(i18n.echo('deleteconfirm'))) {
 69 | 		return false;
 70 | 	}
 71 | 	
 72 | 	var dayGuid = $(this).parent().attr("rel");
 73 | 	if (!dayGuid) {
 74 | 		return false;
 75 | 	}
 76 | 	
 77 | 	var $program = $('#event_manager_event_view_program');
 78 | 	
 79 | 	var $dayElements = $program.find("#day_" + dayGuid + ", .elgg-menu-navigation-tabs a[rel='day_" + dayGuid + "']").parent();
 80 | 	
 81 | 	$program.find('.elgg-menu-navigation-tabs li:first a').click();
 82 | 	
 83 | 	$dayElements.hide();
 84 | 
 85 | 	ajax.action('event_manager/delete_program_item', {
 86 | 		data: {
 87 | 			guid: dayGuid
 88 | 		},
 89 | 		success: function(json) {
 90 | 			$dayElements.remove();
 91 | 		},
 92 | 		error: function() {
 93 | 			$dayElements.show();
 94 | 		}
 95 | 	});
 96 | });
 97 | 
 98 | $(document).on('click', '.event_manager_program_slot_delete', function() {
 99 | 	if (!confirm(i18n.echo('deleteconfirm'))) {
100 | 		return false;
101 | 	}
102 | 	
103 | 	var slotGuid = $(this).parent().attr('rel');
104 | 	if (!slotGuid) {
105 | 		return false;
106 | 	}
107 | 	
108 | 	var $slotElement = $('#' + slotGuid);
109 | 	$slotElement.hide();
110 | 
111 | 	ajax.action('event_manager/delete_program_item', {
112 | 		data: {
113 | 			guid: slotGuid
114 | 		},
115 | 		success: function(json) {
116 | 			$slotElement.remove();
117 | 		},
118 | 		error: function() {
119 | 			$slotElement.show();
120 | 		}
121 | 	});
122 | });
123 | 
124 | $(document).on('click', '#event-manager-new-slot-set-name-button', function() {
125 | 	var set_name = $('#event-manager-new-slot-set-name').val();
126 | 	if (set_name !== '') {
127 | 		$("#event_manager_form_program_slot input[name='slot_set']").prop('checked', false);
128 | 		var $options = $("#event_manager_form_program_slot input[name='slot_set']:first").parent().parent().parent();
129 | 		$options.append("<li><label><input type='radio' checked='checked' value='" + set_name + "' name='slot_set'/>" + set_name + "</label></li>");
130 | 	}
131 | });
132 | 
133 | $(document).on('submit', '#event_manager_form_program_slot', addSlot);
134 | $(document).on('submit', '#event_manager_form_program_day', addDay);
135 | 


--------------------------------------------------------------------------------
/views/default/event_manager/program/view.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event = elgg_extract('entity', $vars);
 4 | if (!$event instanceof \Event) {
 5 | 	return;
 6 | }
 7 | 
 8 | if (!$event->with_program) {
 9 | 	return;
10 | }
11 | 
12 | if ($event->canEdit()) {
13 | 	elgg_import_esm('event_manager/program/view');
14 | }
15 | 
16 | $show_owner_actions = elgg_extract('show_owner_actions', $vars, true);
17 | 
18 | $tab_options = [
19 | 	'id' => 'event_manager_event_view_program',
20 | 	'tabs' => [],
21 | ];
22 | 
23 | $member = elgg_extract('member', $vars);
24 | foreach ($event->getEventDays() as $key => $day) {
25 | 	$tab_options['tabs'][] = [
26 | 		'text' => $day->description ?: event_manager_format_date($day->date),
27 | 		'rel' => "day_{$day->guid}",
28 | 		'content' => elgg_view('event_manager/program/elements/day', [
29 | 			'entity' => $day,
30 | 			'member' => $member,
31 | 			'show_owner_actions' => $show_owner_actions,
32 | 		]),
33 | 		'selected' => ($key === 0),
34 | 	];
35 | }
36 | 
37 | $module_vars = [];
38 | if ($event->canEdit() && $show_owner_actions) {
39 | 	$module_vars['menu'] = elgg_view('output/url', [
40 | 		'href' => false,
41 | 		'rel' => $event->guid,
42 | 		'data-colorbox-opts' => json_encode([
43 | 			'href' => elgg_normalize_url('ajax/view/event_manager/forms/program/day?event_guid=' . $event->guid)
44 | 		]),
45 | 		'class' => 'event_manager_program_day_add elgg-lightbox',
46 | 		'text' => elgg_echo('event_manager:program:day:add'),
47 | 		'icon' => 'plus',
48 | 	]);
49 | }
50 | 
51 | $content = elgg_view('page/components/tabs', $tab_options);
52 | 
53 | echo elgg_view_module('info', elgg_echo('event_manager:event:program'), $content, $module_vars);
54 | 


--------------------------------------------------------------------------------
/views/default/event_manager/registration/completed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event = elgg_extract('event', $vars);
 4 | $object = elgg_extract('object', $vars);
 5 | $rel = $event->getRelationshipByUser($object->guid);
 6 | 
 7 | if ($rel === EVENT_MANAGER_RELATION_ATTENDING) {
 8 | 	$completed_text = $event->registration_completed ?: elgg_echo('event_manager:registration:completed', [$object->getDisplayName(), $event->getDisplayName()]);
 9 | 	
10 | 	$completed_text = str_ireplace('[NAME]', $object->getDisplayName(), $completed_text);
11 | 	$completed_text = str_ireplace('[EVENT]', $event->getDisplayName(), $completed_text);
12 | 	
13 | 	echo elgg_view('output/longtext', ['value' => $completed_text]);
14 | }
15 | 
16 | echo elgg_view('output/longtext', ['value' => elgg_echo('event_manager:event:relationship:message:' . $rel)]);
17 | 
18 | echo elgg_format_element('div', ['class' => 'mtm'], elgg_view('output/url', [
19 | 	'text' => elgg_echo('event_manager:registration:continue'),
20 | 	'href' => $event->getURL(),
21 | 	'class' => 'elgg-button elgg-button-action',
22 | ]));
23 | 


--------------------------------------------------------------------------------
/views/default/event_manager/registration/non_loggedin.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | echo elgg_view_field([
 4 | 	'#type' => 'text',
 5 | 	'#label' => elgg_echo('user:name:label'),
 6 | 	'name' => 'question_name',
 7 | 	'value' => elgg_get_sticky_value('event_register', 'question_name'),
 8 | 	'required' => true,
 9 | ]);
10 | 
11 | echo elgg_view_field([
12 | 	'#type' => 'email',
13 | 	'#label' => elgg_echo('email'),
14 | 	'name' => 'question_email',
15 | 	'value' => elgg_get_sticky_value('event_register', 'question_email'),
16 | 	'required' => true,
17 | ]);
18 | 


--------------------------------------------------------------------------------
/views/default/event_manager/registration/question.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $question = elgg_extract('entity', $vars);
 4 | $value = elgg_extract('value', $vars);
 5 | 
 6 | if (!$question instanceof \EventRegistrationQuestion) {
 7 | 	return;
 8 | }
 9 | 
10 | $fieldtypes = [
11 | 	'Textfield' => 'text',
12 | 	'Textarea' => 'plaintext',
13 | 	'Dropdown' => 'dropdown',
14 | 	'Radiobutton' => 'radio'
15 | ];
16 | 
17 | if (!array_key_exists($question->fieldtype, $fieldtypes)) {
18 | 	return;
19 | }
20 | 
21 | echo elgg_view_field([
22 | 	'#type' => $fieldtypes[$question->fieldtype],
23 | 	'#label' => $question->getDisplayName(),
24 | 	'name' => 'question_' . $question->guid,
25 | 	'value' => $value,
26 | 	'required' => (bool) $question->required,
27 | 	'options' => $question->getOptions(),
28 | ]);
29 | 


--------------------------------------------------------------------------------
/views/default/event_manager/registration/user_data.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event = elgg_extract('event', $vars);
 4 | $entity = elgg_extract('entity', $vars);
 5 | 
 6 | if (empty($event) || empty($entity)) {
 7 | 	return;
 8 | }
 9 | 
10 | $questions = $event->getRegistrationFormQuestions();
11 | $show_title = elgg_extract('show_title', $vars, false);
12 | 
13 | if (empty($questions)) {
14 | 	return;
15 | }
16 | 
17 | if ($show_title) {
18 | 	echo elgg_format_element('h3', [], elgg_echo('event_manager:registration:view:information'));
19 | }
20 | 
21 | if (($entity->guid !== elgg_get_logged_in_user_guid()) && !$entity instanceof \ElggUser) {
22 | 	echo elgg_format_element('label', [], elgg_echo('user:name:label'));
23 | 	echo elgg_format_element('div', ['class' => 'mbm'], $entity->getDisplayName());
24 | 	
25 | 	echo elgg_format_element('label', [], elgg_echo('email'));
26 | 	echo elgg_format_element('div', ['class' => 'mbm'], $entity->email);
27 | }
28 | 
29 | /** @var EventRegistrationQuestion $question */
30 | foreach ($questions as $question) {
31 | 	$answer_value = (string) $question->getAnswerFromUser($entity->guid)?->value;
32 | 	
33 | 	echo elgg_format_element('label', [], $question->getDisplayName());
34 | 	echo elgg_format_element('div', ['class' => 'mbm'], $answer_value);
35 | }
36 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/attendees.mjs:
--------------------------------------------------------------------------------
 1 | import 'jquery';
 2 | import Ajax from 'elgg/Ajax';
 3 | 
 4 | $(document).on('submit', 'form.elgg-form-event-manager-event-attendees', function() {
 5 | 	
 6 | 	var form = this;
 7 | 	var $form = $(form);
 8 | 	var ajax = new Ajax();
 9 | 	
10 | 	ajax.view('event_manager/event/attendees_list', {
11 | 		method: 'POST',
12 | 		data: ajax.objectify(form),
13 | 		success: function(data) {
14 | 			$form.nextAll('ul.elgg-list, ul.elgg-pagination, p.elgg-no-results, div.elgg-list-container').remove();
15 | 			$form.after(data);
16 | 		}
17 | 	});
18 | 	
19 | 	return false;
20 | });
21 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/attendees.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Form to search the attendees of an event
 4 |  *
 5 |  * @uses $vars['entity']       the event
 6 |  * @uses $vars['relationship'] which type of attendees to search for
 7 |  */
 8 | 
 9 | $entity = elgg_extract('entity', $vars);
10 | if (!$entity instanceof \Event) {
11 | 	return;
12 | }
13 | 
14 | $relationship = elgg_extract('relationship', $vars);
15 | if (!array_key_exists($relationship, $entity->getSupportedRelationships())) {
16 | 	return;
17 | }
18 | 
19 | elgg_import_esm('forms/event_manager/event/attendees');
20 | 
21 | echo elgg_view_field([
22 | 	'#type' => 'hidden',
23 | 	'name' => 'guid',
24 | 	'value' => $entity->guid,
25 | ]);
26 | 
27 | echo elgg_view_field([
28 | 	'#type' => 'hidden',
29 | 	'name' => 'relationship',
30 | 	'value' => $relationship,
31 | ]);
32 | 
33 | echo elgg_view_field([
34 | 	'#type' => 'text',
35 | 	'name' => 'q',
36 | 	'title' => elgg_echo('search'),
37 | 	'placeholder' => elgg_echo('event_manager:event:search_attendees'),
38 | 	'value' => elgg_extract('q', $vars, get_input('q')),
39 | ]);
40 | 
41 | $footer = elgg_view_field([
42 | 	'#type' => 'submit',
43 | 	'text' => elgg_echo('search'),
44 | 	'class' => 'hidden',
45 | ]);
46 | 
47 | elgg_set_form_footer($footer);
48 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/copy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $entity = elgg_extract('entity', $vars);
 4 | if (!$entity instanceof \Event) {
 5 | 	return;
 6 | }
 7 | 
 8 | $body = elgg_view('forms/event_manager/event/tabs/general', [
 9 | 	'title' => elgg_echo('event_manager:entity:copy', [$entity->getDisplayName()]),
10 | 	'event_start' => $entity->getStartTimestamp(),
11 | 	'event_end' => $entity->getEndTimestamp(),
12 | 	'announcement_period' => elgg_get_plugin_setting('announcement_period', 'event_manager'),
13 | 	'notification_queued_ts' => ELGG_ENTITIES_ANY_VALUE,
14 | 	'notification_sent_ts' => ELGG_ENTITIES_ANY_VALUE,
15 | ]);
16 | 
17 | $body .= elgg_view_field([
18 | 	'#type' => 'access',
19 | 	'#label' => elgg_echo('access'),
20 | 	'name' => 'access_id',
21 | 	'value' => $entity->access_id,
22 | ]);
23 | 
24 | $body .= elgg_view_field([
25 | 	'#type' => 'hidden',
26 | 	'name' => 'guid',
27 | 	'value' => $entity->guid,
28 | ]);
29 | 
30 | $body .= elgg_view_field([
31 | 	'#type' => 'submit',
32 | 	'text' => elgg_echo('save'),
33 | ]);
34 | 
35 | echo elgg_view_module('info', elgg_echo('event_manager:menu:copy'), $body);
36 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/edit.mjs:
--------------------------------------------------------------------------------
 1 | import 'jquery';
 2 | import 'jquery-ui';
 3 | import 'elgg';
 4 | 
 5 | $('#event_manager_event_edit input[name="registration_needed"]').on('change', function() {
 6 | 	if ($(this).val()) {
 7 | 		$('#event-manager-forms-event-edit-questions, .elgg-menu-item-event-edit-questions').removeClass('hidden');
 8 | 	}
 9 | });
10 | 
11 | $(document).on('change', 'input[name="fee"], input[name="max_attendees"]', function() {
12 | 	var $toggle_field = $(this).parent().parent().next().find('.elgg-field');
13 | 	$toggle_field.addClass('hidden');
14 | 	var entered_value = $(this).val().trim();
15 | 	if (entered_value && (entered_value !== '0')) {
16 | 		$toggle_field.removeClass('hidden');
17 | 	}
18 | });
19 | 
20 | // Registration Questions
21 | $('.event_manager_registrationform_fields').sortable({
22 | 	axis: 'y',
23 | 	tolerance: 'pointer',
24 | 	opacity: 0.8,
25 | 	forcePlaceholderSize: true,
26 | 	forceHelperSize: true,
27 | });
28 | 
29 | $(document).on('click', '.event_manager_questions_delete', function(e) {
30 | 	if (e.isDefaultPrevented()) {
31 | 		return;
32 | 	}
33 | 	
34 | 	$(this).parents('.elgg-item-object-eventregistrationquestion').eq(0).remove();
35 | });
36 | 
37 | $(document).on('change', '.event_manager_registrationform_question_fieldtype', function() {
38 | 	var type = $(this).val();
39 | 	var $parent = $(this).parents('.elgg-item-object-eventregistrationquestion').eq(0);
40 | 	if (type == 'Radiobutton' || type == 'Dropdown') {
41 | 		$parent.find('.event_manager_registrationform_select_options').show();
42 | 	} else {
43 | 		$parent.find('.event_manager_registrationform_select_options').hide();
44 | 	}
45 | });
46 | 
47 | $(document).on('click', '.event-manager-registration-add-field', function() {
48 | 	var $clone = $('#event-manager-registration-field-template').clone();
49 | 	$clone.appendTo('.event_manager_registrationform_fields').removeClass('hidden').removeAttr('id');
50 | 	$clone.find(':disabled').removeAttr('disabled');
51 | 	
52 | 	var d = new Date();
53 | 	var temp_id = 't_' + d.getTime();
54 | 	$($clone).html($clone.html().replace(/questions\[\]\[/g, 'questions[' + temp_id + ']['));
55 | });
56 | 
57 | $(document).on('click', '#event-manager-location-input-delete', function() {
58 | 	$('#event_manager_event_edit').find('input[name="location"], input[name="latitude"], input[name="longitude"]').val('');
59 | 	$(this).closest('.elgg-field').addClass('hidden');
60 | });
61 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/edit.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | elgg_import_esm('forms/event_manager/event/edit');
 4 | 
 5 | $event = elgg_extract('entity', $vars);
 6 | $fields = event_manager_prepare_form_vars($event);
 7 | $vars = array_merge($vars, $fields);
 8 | 
 9 | $maps_provider = event_manager_get_maps_provider();
10 | 
11 | $hidden_inputs = ['guid', 'container_guid'];
12 | 
13 | if ($maps_provider !== 'none') {
14 | 	$hidden_inputs[] = 'latitude';
15 | 	$hidden_inputs[] = 'longitude';
16 | }
17 | 
18 | foreach ($hidden_inputs as $hidden) {
19 | 	echo elgg_view_field([
20 | 		'#type' => 'hidden',
21 | 		'name' => $hidden,
22 | 		'value' => $fields[$hidden],
23 | 	]);
24 | }
25 | 
26 | echo elgg_view('forms/event_manager/event/module', [
27 | 	'body' => elgg_view('forms/event_manager/event/tabs/general', $vars),
28 | ]);
29 | 
30 | $sections = ['profile', 'location', 'contact', 'registration', 'questions'];
31 | foreach ($sections as $section) {
32 | 	echo elgg_view('forms/event_manager/event/module', [
33 | 		'section' => $section,
34 | 		'title' => elgg_echo("event_manager:edit:form:tabs:{$section}"),
35 | 		'id' => "event-manager-forms-event-edit-{$section}",
36 | 		'body' => elgg_view("forms/event_manager/event/tabs/{$section}", $vars),
37 | 		'body_vars' => $vars,
38 | 	]);
39 | }
40 | 
41 | $footer = elgg_view_field([
42 | 	'#type' => 'submit',
43 | 	'text' => elgg_echo('save'),
44 | ]);
45 | 
46 | elgg_set_form_footer($footer);
47 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/edit/event_type.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // current value
 4 | $event_type = elgg_extract('event_type', $vars);
 5 | 
 6 | $type_settings = trim((string) elgg_get_plugin_setting('type_list', 'event_manager'));
 7 | $type_list = explode(',', $type_settings);
 8 | 
 9 | array_walk($type_list, function(&$val) {
10 | 	$val = trim($val);
11 | });
12 | 
13 | $type_list = array_filter($type_list, function($value) {
14 | 	return !elgg_is_empty($value);
15 | });
16 | 
17 | if (empty($type_list)) {
18 | 	if (!empty($region)) {
19 | 		echo elgg_view_field([
20 | 			'#type' => 'hidden',
21 | 			'name' => 'event_type',
22 | 			'value' => $event_type,
23 | 		]);
24 | 	}
25 | 	
26 | 	return;
27 | }
28 | 
29 | $options = array_merge([''], $type_list);
30 | if (!in_array($event_type, $options)) {
31 | 	$options[] = $event_type;
32 | }
33 | 
34 | echo elgg_view_field([
35 | 	'#type' => 'select',
36 | 	'#label' => elgg_echo('event_manager:edit:form:type'),
37 | 	'#help' => elgg_echo('event_manager:edit:form:type:help'),
38 | 	'name' => 'event_type',
39 | 	'value' => $event_type,
40 | 	'options' => $options,
41 | ]);
42 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/edit/region.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // current value
 4 | $region = elgg_extract('region', $vars);
 5 | 
 6 | $region_settings = trim((string) elgg_get_plugin_setting('region_list', 'event_manager'));
 7 | $region_list = explode(',', $region_settings);
 8 | 
 9 | array_walk($region_list, function(&$val) {
10 | 	$val = trim($val);
11 | });
12 | 
13 | $region_list = array_filter($region_list, function($value) {
14 | 	return !elgg_is_empty($value);
15 | });
16 | 
17 | if (empty($region_list)) {
18 | 	if (!empty($region)) {
19 | 		echo elgg_view_field([
20 | 			'#type' => 'hidden',
21 | 			'name' => 'region',
22 | 			'value' => $region,
23 | 		]);
24 | 	}
25 | 	
26 | 	return;
27 | }
28 | 
29 | $options = array_merge([''], $region_list);
30 | if (!in_array($region, $options)) {
31 | 	$options[] = $region;
32 | }
33 | 
34 | echo elgg_view_field([
35 | 	'#type' => 'select',
36 | 	'#label' => elgg_echo('event_manager:edit:form:region'),
37 | 	'#help' => elgg_echo('event_manager:edit:form:region:help'),
38 | 	'name' => 'region',
39 | 	'value' => $region,
40 | 	'options' => $options,
41 | ]);
42 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/mail.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Mail event attendees form
 4 |  */
 5 | 
 6 | $entity = elgg_extract('entity', $vars);
 7 | if (!$entity instanceof \Event) {
 8 | 	return;
 9 | }
10 | 
11 | echo elgg_view_field([
12 | 	'#type' => 'hidden',
13 | 	'name' => 'guid',
14 | 	'value' => $entity->guid,
15 | ]);
16 | 
17 | echo elgg_view_field([
18 | 	'#type' => 'text',
19 | 	'#label' => elgg_echo('email:subject'),
20 | 	'name' => 'title',
21 | 	'value' => elgg_extract('title', $vars),
22 | 	'required' => true,
23 | ]);
24 | 
25 | echo elgg_view_field([
26 | 	'#type' => 'plaintext',
27 | 	'#label' => elgg_echo('email:body'),
28 | 	'name' => 'description',
29 | 	'value' => elgg_extract('description', $vars),
30 | 	'required' => true,
31 | ]);
32 | 
33 | $recipient_options = $entity->getSupportedRelationships();
34 | unset($recipient_options[EVENT_MANAGER_RELATION_ATTENDING_PENDING]);
35 | foreach ($recipient_options as $rel => $text) {
36 | 	$count = $entity->getEntitiesFromRelationship([
37 | 		'count' => true,
38 | 		'relationship' => $rel,
39 | 	]);
40 | 	
41 | 	$recipient_options[$rel] = "{$text} ({$count})";
42 | }
43 | 
44 | $contacts = $entity->getContacts(['count' => true]);
45 | if (!empty($contacts)) {
46 | 	$recipient_options['contacts'] = elgg_echo('event_manager:event:view:contact_persons') . " ({$contacts})";
47 | }
48 | 
49 | $organizers = $entity->getOrganizers(['count' => true]);
50 | if (!empty($organizers)) {
51 | 	$recipient_options[EVENT_MANAGER_RELATION_ORGANIZING] = elgg_echo('event_manager:event:relationship:event_organizing:label') . " ({$organizers})";
52 | }
53 | 
54 | echo elgg_view_field([
55 | 	'#type' => 'checkboxes',
56 | 	'#label' => elgg_echo('event_manager:mail:recipients'),
57 | 	'name' => 'recipients',
58 | 	'options_values' => $recipient_options,
59 | 	'value' => elgg_extract('recipients', $vars),
60 | ]);
61 | 
62 | $footer = elgg_view_field([
63 | 	'#type' => 'submit',
64 | 	'text' => elgg_echo('send'),
65 | ]);
66 | 
67 | elgg_set_form_footer($footer);
68 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/module.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | $section = elgg_extract('section', $vars);
  4 | 
  5 | // use a view var event to toggle default collapsability or per section
  6 | $collapsed = elgg_extract('collapsed', $vars, true);
  7 | 
  8 | $title = (string) elgg_extract('title', $vars);
  9 | $body = elgg_extract('body', $vars);
 10 | $body_vars = elgg_extract('body_vars', $vars, []);
 11 | $entity = elgg_extract('entity', $body_vars);
 12 | 
 13 | if ($collapsed) {
 14 | 	// check (for supported sections) if they need to show expanded
 15 | 	switch ($section) {
 16 | 		case 'contact':
 17 | 			$organizer = elgg_extract('organizer', $body_vars);
 18 | 			$contact_details = elgg_extract('contact_details', $body_vars);
 19 | 			$website = elgg_extract('website', $body_vars);
 20 | 			$organizer_guids = elgg_extract('organizer_guids', $body_vars);
 21 | 			$contact_guids = elgg_extract('contact_guids', $body_vars);
 22 | 			
 23 | 			if (!empty($organizer) || !empty($organizer_guids) || !empty($contact_guids) || !empty($contact_details) || !empty($website)) {
 24 | 				$collapsed = false;
 25 | 			}
 26 | 			break;
 27 | 		case 'location':
 28 | 			$venue = elgg_extract('venue', $body_vars);
 29 | 			$location = elgg_extract('location', $body_vars);
 30 | 			$region = elgg_extract('region', $body_vars);
 31 | 			
 32 | 			if (!empty($venue) || !empty($location) || !empty($region)) {
 33 | 				$collapsed = false;
 34 | 			}
 35 | 			break;
 36 | 		case 'profile':
 37 | 			$shortdescription = elgg_extract('shortdescription', $body_vars);
 38 | 			$description = elgg_extract('description', $body_vars);
 39 | 			
 40 | 			if (!empty($shortdescription) || !empty($description)) {
 41 | 				$collapsed = false;
 42 | 			}
 43 | 			break;
 44 | 		case 'registration':
 45 | 			$fee = elgg_extract('fee', $body_vars);
 46 | 			$max_attendees = elgg_extract('max_attendees', $body_vars);
 47 | 			
 48 | 			if (!empty($fee) || !empty($max_attendees)) {
 49 | 				$collapsed = false;
 50 | 			}
 51 | 			break;
 52 | 		default:
 53 | 			// unsupported sections are not collapsed
 54 | 			$collapsed = false;
 55 | 			break;
 56 | 	}
 57 | }
 58 | 
 59 | $menu = null;
 60 | if ($collapsed) {
 61 | 	elgg_import_esm('elgg/toggle');
 62 | 	
 63 | 	$menu = elgg_view('input/button', [
 64 | 		'class' => [
 65 | 			"event-manager-edit-{$section}-toggle",
 66 | 			'elgg-button-action',
 67 | 			'elgg-toggle',
 68 | 		],
 69 | 		'text' => elgg_echo('event_manager:edit:form:tabs:toggle'),
 70 | 		'data-toggle-slide' => 0,
 71 | 		'data-toggle-selector' => ".event-manager-edit-{$section}-toggle",
 72 | 	]);
 73 | 	
 74 | 	$body = elgg_format_element('div', [
 75 | 		'class' => "hidden event-manager-edit-{$section}-toggle",
 76 | 		'data-toggle-slide' => 0,
 77 | 	], $body);
 78 | 	
 79 | 	$body .= elgg_format_element('div', [
 80 | 		'class' => "event-manager-edit-{$section}-toggle",
 81 | 		'data-toggle-slide' => 0,
 82 | 	], elgg_echo("event_manager:edit:form:tabs:{$section}:toggle"));
 83 | }
 84 | 
 85 | $module_vars = [
 86 | 	'id' => elgg_extract('id', $vars),
 87 | 	'class' => ['event_tab'],
 88 | 	'menu' => $menu,
 89 | ];
 90 | 
 91 | if ($section == 'questions') {
 92 | 	if (!$entity instanceof \Event) {
 93 | 		$module_vars['class'][] = 'hidden';
 94 | 	} elseif (!$entity->getRegistrationFormQuestions(true) && !$entity->registration_needed) {
 95 | 		$module_vars['class'][] = 'hidden';
 96 | 	}
 97 | }
 98 | 
 99 | echo elgg_view_module('info', $title, $body, $module_vars);
100 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/register.mjs:
--------------------------------------------------------------------------------
 1 | import 'jquery';
 2 | import i18n from 'elgg/i18n';
 3 | import system_messages from 'elgg/system_messages';
 4 | 
 5 | var $form = $("#event_manager_event_register");
 6 | if ($form.length > 0) {
 7 | 	var set_names = []; // store processed set names
 8 | 
 9 | 	$form.find(".event_manager_program_participatetoslot[rel]:checked").each(function(){
10 | 		var rel = $(this).attr("rel");
11 | 		if ($.inArray(rel, set_names) < 0) {
12 | 			set_names.push[rel];
13 | 			$form.find(".event_manager_program_participatetoslot[rel='" + rel + "'][id!='" + $(this).attr("id") + "']").removeAttr("checked").attr("disabled", "disabled");
14 | 		}
15 | 	});
16 | 
17 | 	$(document).on('change', '#event_manager_event_register .event_manager_program_participatetoslot[rel]', function() {
18 | 		var $form = $("#event_manager_event_register");
19 | 		var rel = $(this).attr("rel");
20 | 		var selected_id = $form.find(".event_manager_program_participatetoslot[rel='" + rel + "']:checked:first").attr("id");
21 | 		if (selected_id) {
22 | 			// disabled others
23 | 			$form.find(".event_manager_program_participatetoslot[rel='" + rel + "'][id!='" + selected_id + "']").removeAttr("checked").attr("disabled", "disabled");
24 | 		} else {
25 | 			// enable others
26 | 			$form.find(".event_manager_program_participatetoslot[rel='" + rel + "']").removeAttr("checked").removeAttr("disabled");
27 | 		}
28 | 	});
29 | }
30 | 
31 | $(document).on('submit', '#event_manager_event_register', function() {
32 | 	if (($("input[name='question_name']").val() === "") || ($("input[name='question_email']").val() === "")) {
33 | 		system_messages.error(i18n.echo("event_manager:registration:required_fields"));
34 | 		return false;
35 | 	}
36 | 
37 | 	var error_found = false;
38 | 
39 | 	$("#event_manager_registration_form_fields .elgg-field-required [required]").each(function(index, elem){
40 | 		if ($(this).hasClass("elgg-input-radios")) {
41 | 			if ($(this).find("input[type='radio']:checked").length === 0) {
42 | 				error_found = true;
43 | 				return false;
44 | 			}
45 | 		} else if ($(this).val() === "") {
46 | 			error_found = true;
47 | 			return false;
48 | 		}
49 | 	});
50 | 
51 | 	if (error_found) {
52 | 		system_messages.error(i18n.echo("event_manager:registration:required_fields"));
53 | 		return false;
54 | 	}
55 | 
56 | 	var guids = [];
57 | 	$.each($('.event_manager_program_participatetoslot'), function(i, value) {
58 | 		var elementId = $(value).attr('id');
59 | 		if ($(value).is(':checked')) {
60 | 			guids.push(elementId.substring(9, elementId.length));
61 | 		}
62 | 	});
63 | 
64 | 	$('#event_manager_program_guids').val(guids.join(','));
65 | });
66 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/register.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | elgg_import_esm('forms/event_manager/event/register');
 4 | 
 5 | $event = elgg_extract('entity', $vars);
 6 | $register_type = elgg_extract('register_type', $vars, 'register');
 7 | 
 8 | $show_required = false;
 9 | 
10 | $form_body = '';
11 | 
12 | if (!elgg_is_logged_in()) {
13 | 	$form_body .= elgg_view('event_manager/registration/non_loggedin');
14 | 	$show_required = true;
15 | }
16 | 
17 | $registration_form = $event->getRegistrationFormQuestions();
18 | if ($registration_form) {
19 | 	if ($register_type == 'waitinglist') {
20 | 		$form_body .= '<p>' . elgg_echo('event_manager:event:rsvp:waiting_list:message') . '</p><br />';
21 | 	}
22 | 
23 | 	foreach ($registration_form as $question) {
24 | 		$value = elgg_get_sticky_value('event_register', 'question_' . $question->guid);
25 | 		if ($value === null && elgg_is_logged_in()) {
26 | 			$value = $question->getAnswerFromUser()?->value;
27 | 		}
28 | 
29 | 		$form_body .= elgg_view('event_manager/registration/question', [
30 | 			'entity' => $question,
31 | 			'value' => $value,
32 | 		]);
33 | 
34 | 		if ($question->required) {
35 | 			$show_required = true;
36 | 		}
37 | 	}
38 | }
39 | 
40 | if ($show_required) {
41 | 	$form_body .= elgg_format_element('div', ['class' => 'elgg-subtext'], elgg_echo('event_manager:registration:required_fields:info'));
42 | }
43 | 
44 | if (!empty($form_body)) {
45 | 	$form_body = elgg_view_module('info', '', $form_body, ['id' => 'event_manager_registration_form_fields']);
46 | }
47 | 
48 | if ($event->with_program) {
49 | 	$form_body .= $event->getProgramData(elgg_get_logged_in_user_guid(), true, $register_type);
50 | }
51 | 
52 | if (!$form_body) {
53 | 	return;
54 | }
55 | 
56 | $form_body .= elgg_view_field([
57 | 	'#type' => 'hidden',
58 | 	'name' => 'event_guid',
59 | 	'value' => $event->guid,
60 | ]);
61 | 
62 | $form_body .= elgg_view_field([
63 | 	'#type' => 'hidden',
64 | 	'name' => 'register_type',
65 | 	'value' => $register_type,
66 | ]);
67 | 
68 | if ($register_type == 'register') {
69 | 	$form_body .= elgg_view_field([
70 | 		'#type' => 'hidden',
71 | 		'name' => 'relation',
72 | 		'value' => EVENT_MANAGER_RELATION_ATTENDING,
73 | 	]);
74 | } elseif ($register_type == 'waitinglist') {
75 | 	$form_body .= elgg_view_field([
76 | 		'#type' => 'hidden',
77 | 		'name' => 'relation',
78 | 		'value' => EVENT_MANAGER_RELATION_ATTENDING_WAITINGLIST,
79 | 	]);
80 | }
81 | 	
82 | $form_body .= elgg_view_field([
83 | 	'#type' => 'submit',
84 | 	'text' => elgg_echo('register'),
85 | ]);
86 | 
87 | echo $form_body;
88 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/tabs/contact.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | elgg_import_esm('elgg/toggle');
 4 | 
 5 | $organizer = elgg_extract('organizer', $vars);
 6 | $contact_details = elgg_extract('contact_details', $vars);
 7 | $website = elgg_extract('website', $vars);
 8 | $organizer_guids = elgg_extract('organizer_guids', $vars);
 9 | $contact_guids = elgg_extract('contact_guids', $vars);
10 | 
11 | $output = elgg_view_field([
12 | 	'#type' => 'fieldset',
13 | 	'#label' => elgg_echo('event_manager:edit:form:organizer'),
14 | 	'align' => 'horizontal',
15 | 	'fields' => [
16 | 		[
17 | 			'#type' => 'text',
18 | 			'#class' => 'elgg-field-stretch',
19 | 			'#help' => elgg_echo('event_manager:edit:form:organizer:help'),
20 | 			'name' => 'organizer',
21 | 			'value' => $organizer,
22 | 		],
23 | 		[
24 | 			'#html' => elgg_echo('event_manager:edit:form:users:or'),
25 | 		],
26 | 		[
27 | 			'#type' => 'button',
28 | 			'text' => elgg_echo('event_manager:edit:form:users:add'),
29 | 			'class' => ['elgg-button-action', 'elgg-toggle'],
30 | 			'data-toggle-selector' => '.event-manager-contact-organizer-guids',
31 | 		],
32 | 	],
33 | ]);
34 | 
35 | $field_classes = ['event-manager-contact-organizer-guids'];
36 | if (empty($organizer_guids)) {
37 | 	$field_classes[] = 'hidden';
38 | }
39 | 
40 | $output .= elgg_view_field([
41 | 	'#type' => 'userpicker',
42 | 	'#label' => elgg_echo('event_manager:edit:form:organizer_guids'),
43 | 	'#class' => $field_classes,
44 | 	'name' => 'organizer_guids',
45 | 	'values' => $organizer_guids,
46 | 	'show_friends' => false,
47 | ]);
48 | 
49 | $output .= elgg_view_field([
50 | 	'#type' => 'fieldset',
51 | 	'#label' => elgg_echo('event_manager:edit:form:contact_details'),
52 | 	'align' => 'horizontal',
53 | 	'fields' => [
54 | 		[
55 | 			'#type' => 'text',
56 | 			'#class' => 'elgg-field-stretch',
57 | 			'#help' => elgg_echo('event_manager:edit:form:contact_details:help'),
58 | 			'name' => 'contact_details',
59 | 			'value' => $contact_details,
60 | 		],
61 | 		[
62 | 			'#html' => elgg_echo('event_manager:edit:form:users:or'),
63 | 		],
64 | 		[
65 | 			'#type' => 'button',
66 | 			'text' => elgg_echo('event_manager:edit:form:users:add'),
67 | 			'class' => ['elgg-button-action', 'elgg-toggle'],
68 | 			'data-toggle-selector' => '.event-manager-contact-contact-guids',
69 | 		],
70 | 	],
71 | ]);
72 | 
73 | $field_classes = ['event-manager-contact-contact-guids'];
74 | if (empty($contact_guids)) {
75 | 	$field_classes[] = 'hidden';
76 | }
77 | 
78 | $output .= elgg_view_field([
79 | 	'#type' => 'userpicker',
80 | 	'#label' => elgg_echo('event_manager:edit:form:contact_guids'),
81 | 	'#class' => $field_classes,
82 | 	'name' => 'contact_guids',
83 | 	'values' => $contact_guids,
84 | 	'show_friends' => false,
85 | ]);
86 | 
87 | $output .= elgg_view_field([
88 | 	'#type' => 'url',
89 | 	'#label' => elgg_echo('event_manager:edit:form:website'),
90 | 	'#help' => elgg_echo('event_manager:edit:form:website:help'),
91 | 	'name' => 'website',
92 | 	'value' => $website,
93 | ]);
94 | 
95 | echo $output;
96 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/tabs/general.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | use Elgg\Values;
 3 | 
 4 | /**
 5 |  * Form fields for general event information
 6 |  */
 7 | 
 8 | echo elgg_view_field([
 9 | 	'#type' => 'text',
10 | 	'#label' => elgg_echo('title'),
11 | 	'name' => 'title',
12 | 	'value' => $vars['title'],
13 | 	'required' => true,
14 | ]);
15 | 
16 | echo elgg_view_field([
17 | 	'#type' => 'fieldset',
18 | 	'align' => 'horizontal',
19 | 	'fields' => [
20 | 		[
21 | 			'#type' => 'date',
22 | 			'#label' => elgg_echo('event_manager:edit:form:start'),
23 | 			'#class' => 'elgg-field-horizontal',
24 | 			'name' => 'event_start',
25 | 			'timestamp' => true,
26 | 			'required' => true,
27 | 			'value' => $vars['event_start'],
28 | 			'class' => 'event_manager_event_edit_date',
29 | 		],
30 | 		[
31 | 			'#type' => 'time',
32 | 			'name' => 'start_time',
33 | 			'value' => $vars['event_start'],
34 | 			'timestamp' => true,
35 | 			'title' => elgg_echo('event_manager:edit:form:start_time'),
36 | 		],
37 | 		[
38 | 			'#type' => 'date',
39 | 			'#label' => elgg_echo('event_manager:edit:form:end'),
40 | 			'#class' => 'elgg-field-horizontal',
41 | 			'name' => 'event_end',
42 | 			'timestamp' => true,
43 | 			'required' => true,
44 | 			'value' => $vars['event_end'],
45 | 			'class' => 'event_manager_event_edit_date',
46 | 		],
47 | 		[
48 | 			'#type' => 'time',
49 | 			'name' => 'end_time',
50 | 			'value' => $vars['event_end'],
51 | 			'timestamp' => true,
52 | 			'title' => elgg_echo('event_manager:edit:form:end_time'),
53 | 		],
54 | 	],
55 | ]);
56 | 
57 | $announcement_period = $vars['announcement_period'];
58 | $notification_queued_ts = $vars['notification_queued_ts'];
59 | $notification_sent_ts = $vars['notification_sent_ts'];
60 | 
61 | if (!empty($notification_sent_ts)) {
62 | 	// notification already sent
63 | 	echo elgg_format_element('div', ['class' => 'elgg-subtext'], elgg_echo('event_manager:edit:form:announcement_period:sent', [Values::normalizeTime($notification_sent_ts)->formatLocale(elgg_echo('friendlytime:date_format:short'))]));
64 | 	
65 | 	return;
66 | }
67 | 
68 | if (!empty($notification_queued_ts) && $notification_queued_ts <= time()) {
69 | 	// notification scheduled in the past
70 | 	echo elgg_format_element('div', ['class' => 'elgg-subtext'], elgg_echo('event_manager:edit:form:announcement_period:scheduled', [Values::normalizeTime($notification_queued_ts)->formatLocale(elgg_echo('friendlytime:date_format:short'))]));
71 | 	
72 | 	return;
73 | }
74 | 
75 | if (!empty($vars['guid']) && empty($notification_queued_ts)) {
76 | 	// scheduled notifications not supported, probably an event created before this feature existed
77 | 	return;
78 | }
79 | 
80 | echo elgg_view_field([
81 | 	'#type' => 'number',
82 | 	'#label' => elgg_echo('event_manager:edit:form:announcement_period'),
83 | 	'#help' => elgg_echo('event_manager:edit:form:announcement_period:help'),
84 | 	'name' => 'announcement_period',
85 | 	'value' => $announcement_period,
86 | 	'min' => 0,
87 | ]);
88 | 
89 | if (!empty($notification_queued_ts)) {
90 | 	// notification scheduled in the future
91 | 	echo elgg_format_element('div', ['class' => 'elgg-subtext'], elgg_echo('event_manager:edit:form:announcement_period:scheduled', [Values::normalizeTime($notification_queued_ts)->formatLocale(elgg_echo('friendlytime:date_format:short'))]));
92 | }
93 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/tabs/location.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Form fields for event location data
 4 |  */
 5 | 
 6 | $venue = elgg_extract('venue', $vars);
 7 | $location = elgg_extract('location', $vars);
 8 | 
 9 | $maps_provider = event_manager_get_maps_provider();
10 | 
11 | $output = elgg_view_field([
12 | 	'#type' => 'text',
13 | 	'#label' => elgg_echo('event_manager:edit:form:venue'),
14 | 	'#help' => elgg_echo('event_manager:edit:form:venue:help'),
15 | 	'name' => 'venue',
16 | 	'value' => $venue,
17 | ]);
18 | 
19 | $field_options = [
20 | 	'#type' => 'fieldset',
21 | 	'align' => 'horizontal',
22 | 	'class' => 'event-manager-align-bottom',
23 | 	'fields' => [
24 | 		[
25 | 			'#type' => 'text',
26 | 			'#class' => 'elgg-field-stretch',
27 | 			'#label' => elgg_echo('event_manager:edit:form:location'),
28 | 			'#help' => elgg_echo('event_manager:edit:form:location:help'),
29 | 			'name' => 'location',
30 | 			'value' => $location,
31 | 		],
32 | 		[
33 | 			'#type' => 'button',
34 | 			'#class' => $location ? null : 'hidden',
35 | 			'text' => elgg_echo('delete'),
36 | 			'id' => 'event-manager-location-input-delete',
37 | 			'class' => [
38 | 				'elgg-button-delete',
39 | 			],
40 | 		],
41 | 	],
42 | ];
43 | 
44 | if (elgg_view_exists("event_manager/maps/{$maps_provider}/location_input")) {
45 | 	$field_options['data-has-maps'] = true;
46 | 	
47 | 	$params = $vars;
48 | 	$params['field_options'] = $field_options;
49 | 	$output .= elgg_view("event_manager/maps/{$maps_provider}/location_input", $params);
50 | 	$output .= elgg_view('forms/event_manager/event/tabs/location_search', $vars);
51 | } else {
52 | 	$output .= elgg_view_field($field_options);
53 | }
54 | 
55 | $output .= elgg_view('forms/event_manager/event/edit/region', $vars);
56 | 
57 | echo $output;
58 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/tabs/location_search.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $form = elgg_format_element('div', ['id' => 'event-manager-maps-location-search']);
 4 | 
 5 | $form .= elgg_view_field([
 6 | 	'#type' => 'text',
 7 | 	'#label' => elgg_echo('event_manager:event:edit:maps_address'),
 8 | 	'name' => 'address_search',
 9 | 	'id' => 'address_search',
10 | ]);
11 | 
12 | $form .= elgg_view_field([
13 | 	'#type' => 'fieldset',
14 | 	'align' => 'horizontal',
15 | 	'fields' => [
16 | 		[
17 | 			'#type' => 'button',
18 | 			'class' => 'elgg-button-submit elgg-button-action',
19 | 			'name' => 'address_search_submit',
20 | 			'text' => elgg_echo('search'),
21 | 		],
22 | 		[
23 | 			'#type' => 'button',
24 | 			'class' => 'elgg-button-submit hidden',
25 | 			'name' => 'address_search_save',
26 | 			'id' => 'address_search_save',
27 | 			'text' => elgg_echo('save'),
28 | 		],
29 | 	],
30 | ]);
31 | 
32 | $container = elgg_format_element('div', ['id' => 'event-manager-edit-maps-search-container'], $form);
33 | 
34 | echo elgg_format_element('div', ['class' => 'hidden'], $container);
35 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/tabs/profile.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Form fields for editing event details
 4 |  */
 5 | 
 6 | echo elgg_view_field([
 7 | 	'#type' => 'text',
 8 | 	'#label' => elgg_echo('event_manager:edit:form:shortdescription'),
 9 | 	'#help' => elgg_echo('event_manager:edit:form:shortdescription:help'),
10 | 	'name' => 'shortdescription',
11 | 	'value' => elgg_extract('shortdescription', $vars),
12 | ]);
13 | 
14 | echo elgg_view_field([
15 | 	'#type' => 'longtext',
16 | 	'#label' => elgg_echo('description'),
17 | 	'#help' => elgg_echo('event_manager:edit:form:description:help'),
18 | 	'name' => 'description',
19 | 	'value' => elgg_extract('description', $vars),
20 | ]);
21 | 
22 | echo elgg_view_field([
23 | 	'#type' => 'tags',
24 | 	'#label' => elgg_echo('tags'),
25 | 	'#help' => elgg_echo('event_manager:edit:form:tags:help'),
26 | 	'name' => 'tags',
27 | 	'value' => elgg_extract('tags', $vars),
28 | ]);
29 | 
30 | echo elgg_view('entity/edit/header', [
31 | 	'entity' => elgg_extract('entity', $vars),
32 | 	'entity_type' => 'object',
33 | 	'entity_subtype' => 'event',
34 | ]);
35 | 
36 | echo elgg_view('forms/event_manager/event/edit/event_type', $vars);
37 | 
38 | echo elgg_view_field([
39 | 	'#type' => 'checkbox',
40 | 	'#label' => elgg_echo('event_manager:edit:form:comments_on'),
41 | 	'#help' => elgg_echo('event_manager:edit:form:comments_on:help'),
42 | 	'name' => 'comments_on',
43 | 	'checked' => (int) $vars['comments_on'] === 1,
44 | 	'switch' => true,
45 | 	'default' => '0',
46 | 	'value' => '1',
47 | ]);
48 | 
49 | echo elgg_view_field([
50 | 	'#type' => 'access',
51 | 	'#label' => elgg_echo('access'),
52 | 	'name' => 'access_id',
53 | 	'value' => $vars['access_id'],
54 | ]);
55 | 
56 | echo elgg_view_field([
57 | 	'#type' => 'container_guid',
58 | 	'entity_type' => 'object',
59 | 	'entity_subtype' => \Event::SUBTYPE,
60 | 	'value' => $vars['container_guid'],
61 | ]);
62 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/tabs/questions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | $event = elgg_extract('entity', $vars);
 3 | 
 4 | // Have to do this for private events
 5 | echo elgg_call(ELGG_IGNORE_ACCESS, function() use ($event) {
 6 | 	$results = '';
 7 | 	$no_results = function() {
 8 | 		echo elgg_format_element('ul', [
 9 | 			'class' => 'elgg-list event_manager_registrationform_fields',
10 | 		]);
11 | 	};
12 | 	
13 | 	if ($event instanceof \Event) {
14 | 		$results .= elgg_view_entity_list($event->getRegistrationFormQuestions(), [
15 | 			'list_class' => 'event_manager_registrationform_fields',
16 | 			'item_view' => 'forms/event_manager/registrationform/question',
17 | 			'no_results' => $no_results,
18 | 		]);
19 | 	} else {
20 | 		$results .= $no_results();
21 | 	}
22 | 	
23 | 	$results .= elgg_format_element('ul', [], elgg_format_element('li', [
24 | 		'id' => 'event-manager-registration-field-template',
25 | 		'class' => 'hidden elgg-item elgg-item-object elgg-item-object-eventregistrationquestion ui-sortable-handle',
26 | 	], elgg_view('forms/event_manager/registrationform/question')));
27 | 	
28 | 	$results .= elgg_view('output/url', [
29 | 		'href' => false,
30 | 		'class' => 'elgg-button elgg-button-action event-manager-registration-add-field',
31 | 		'text' => elgg_echo('event_manager:editregistration:addfield'),
32 | 	]);
33 | 	
34 | 	return $results;
35 | });
36 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/unsubscribe.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $entity = elgg_extract('entity', $vars);
 4 | $email = elgg_get_sticky_value('event_unsubscribe', 'email', get_input('e'));
 5 | 
 6 | echo elgg_view_field([
 7 | 	'#type' => 'hidden',
 8 | 	'name' => 'guid',
 9 | 	'value' => $entity->guid,
10 | ]);
11 | 
12 | echo elgg_view('output/longtext', ['value' => elgg_echo('event_manager:unsubscribe:description', [$entity->getDisplayName()])]);
13 | 
14 | echo elgg_view_field([
15 | 	'#type' => 'email',
16 | 	'#label' => elgg_echo('email'),
17 | 	'name' => 'email',
18 | 	'value' => $email,
19 | 	'id' => 'event-manager-unsubscribe-email',
20 | ]);
21 | 
22 | $footer = elgg_view_field([
23 | 	'#type' => 'submit',
24 | 	'text' => elgg_echo('submit'),
25 | ]);
26 | 
27 | elgg_set_form_footer($footer);
28 | 
29 | elgg_clear_sticky_form('event_unsubscribe');
30 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/unsubscribe_confirm.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event = elgg_extract('entity', $vars);
 4 | $registration = elgg_extract('registration', $vars);
 5 | $code = elgg_extract('code', $vars);
 6 | 
 7 | echo elgg_view('output/longtext', [
 8 | 	'value' => elgg_echo('event_manager:unsubscribe_confirm:description', [$registration->getDisplayName(), $event->getDisplayName()]),
 9 | ]);
10 | 
11 | echo elgg_view('input/hidden', ['name' => 'registration', 'value' => $registration->guid]);
12 | echo elgg_view('input/hidden', ['name' => 'event', 'value' => $event->guid]);
13 | echo elgg_view('input/hidden', ['name' => 'code', 'value' => $code]);
14 | 
15 | $footer = elgg_view('input/submit', ['text' => elgg_echo('confirm')]);
16 | 
17 | elgg_set_form_footer($footer);
18 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/event/upload_file.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event = elgg_extract('entity', $vars);
 4 | if (empty($event)) {
 5 | 	return;
 6 | }
 7 | 
 8 | echo elgg_view_field([
 9 | 	'#type' => 'hidden',
10 | 	'name' => 'guid',
11 | 	'value' => $event->guid,
12 | ]);
13 | 
14 | echo elgg_view_field([
15 | 	'#type' => 'text',
16 | 	'#label' => elgg_echo('title'),
17 | 	'name' => 'title',
18 | 	'required' => true
19 | ]);
20 | 
21 | echo elgg_view_field([
22 | 	'#type' => 'file',
23 | 	'#label' => elgg_echo('event_manager:edit:form:file'),
24 | 	'name' => 'file',
25 | 	'required' => true,
26 | ]);
27 | 
28 | $footer = elgg_view_field([
29 | 	'#type' => 'submit',
30 | 	'text' => elgg_echo('upload'),
31 | ]);
32 | 
33 | elgg_set_form_footer($footer);
34 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/registration/confirm.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event = elgg_extract('event', $vars);
 4 | $user = elgg_extract('user', $vars);
 5 | $code = elgg_extract('code', $vars);
 6 | 
 7 | echo elgg_view('output/longtext', [
 8 | 	'value' => elgg_echo('event_manager:registration:confirm:description', [$event->getDisplayName()]),
 9 | ]);
10 | 
11 | echo elgg_view('input/hidden', ['name' => 'event_guid', 'value' => $event->guid]);
12 | echo elgg_view('input/hidden', ['name' => 'user_guid', 'value' => $user->guid]);
13 | echo elgg_view('input/hidden', ['name' => 'code', 'value' => $code]);
14 | 
15 | $footer = elgg_view('input/submit', ['text' => elgg_echo('confirm')]);
16 | $footer .= elgg_view('output/url', [
17 | 	'text' => elgg_echo('delete'),
18 | 	'confirm' => elgg_echo('event_manager:registration:confirm:delete'),
19 | 	'href' => elgg_generate_action_url('event_manager/event/rsvp', [
20 | 		'guid' => $event->guid,
21 | 		'user' => $user->guid,
22 | 		'code' => $code,
23 | 		'type' => EVENT_MANAGER_RELATION_UNDO,
24 | 		'forward_url' => $event->getURL(),
25 | 	]),
26 | 	'class' => 'float-alt elgg-button elgg-button-delete',
27 | ]);
28 | 
29 | elgg_set_form_footer($footer);
30 | 


--------------------------------------------------------------------------------
/views/default/forms/event_manager/registrationform/question.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $question = elgg_extract('entity', $vars);
 4 | 
 5 | $fieldtype = null;
 6 | $fieldoptions = null;
 7 | $required = null;
 8 | $guid = null;
 9 | $title = null;
10 | 
11 | if ($question instanceof \EventRegistrationQuestion) {
12 | 	// assume day edit mode
13 | 	$guid = $question->guid;
14 | 	$title = $question->title;
15 | 	$fieldtype = $question->fieldtype;
16 | 	$required = $question->required;
17 | 	$fieldoptions = $question->fieldoptions;
18 | }
19 | 
20 | $disabled = empty($guid);
21 | 
22 | $fields = [
23 | 	[
24 | 		'#type' => 'hidden',
25 | 		'name' => "questions[{$guid}][guid]",
26 | 		'value' => $guid,
27 | 		'disabled' => $disabled,
28 | 	],
29 | 	[
30 | 		'#type' => 'text',
31 | 		'#label' => elgg_echo('event_manager:editregistration:question'),
32 | 		'#class' => 'mbs',
33 | 		'name' => "questions[{$guid}][questiontext]",
34 | 		'value' => $title,
35 | 		'placeholder' => elgg_echo('event_manager:registrationform:editquestion:text:placeholder'),
36 | 		'disabled' => $disabled,
37 | 	],
38 | 	[
39 | 		'#type' => 'checkbox',
40 | 		'#label' => elgg_echo('event_manager:registrationform:editquestion:required'),
41 | 		'name' => "questions[{$guid}][required]",
42 | 		'checked' => (bool) $required,
43 | 		'switch' => true,
44 | 		'default' => 0,
45 | 		'value' => 1,
46 | 		'disabled' => $disabled,
47 | 	],
48 | 	[
49 | 		'#type' => 'fieldset',
50 | 		'align' => 'horizontal',
51 | 		'fields' => [
52 | 			[
53 | 				'#type' => 'select',
54 | 				'#label' => elgg_echo('event_manager:editregistration:fieldtype'),
55 | 				'#class' => 'man',
56 | 				'class' => 'event_manager_registrationform_question_fieldtype',
57 | 				'value' => $fieldtype,
58 | 				'name' => "questions[{$guid}][fieldtype]",
59 | 				'options_values' => [
60 | 					'Textfield' => elgg_echo('event_manager:editregistration:fieldtype:text'),
61 | 					'Textarea' => elgg_echo('event_manager:editregistration:fieldtype:longtext'),
62 | 					'Dropdown' => elgg_echo('event_manager:editregistration:fieldtype:select'),
63 | 					'Radiobutton' => elgg_echo('event_manager:editregistration:fieldtype:radio'),
64 | 				],
65 | 				'disabled' => $disabled,
66 | 			],
67 | 			[
68 | 				'#type' => 'text',
69 | 				'#label' => elgg_echo('event_manager:editregistration:fieldoptions'),
70 | 				'#class' => [
71 | 					'event_manager_registrationform_select_options',
72 | 					'elgg-field-stretch',
73 | 					in_array($fieldtype, ['Radiobutton', 'Dropdown']) ? null : 'hidden',
74 | 				],
75 | 				'name' => "questions[{$guid}][fieldoptions]",
76 | 				'value' => $fieldoptions,
77 | 				'placeholder' => elgg_echo('event_manager:editregistration:commasepatared'),
78 | 				'disabled' => $disabled,
79 | 			],
80 | 		],
81 | 	],
82 | ];
83 | 
84 | $form_body = '';
85 | foreach ($fields as $field) {
86 | 	$form_body .= elgg_view_field($field);
87 | }
88 | 
89 | $delete_question = elgg_view('output/url', [
90 | 	'icon' => 'delete',
91 | 	'text' => false,
92 | 	'href' => false,
93 | 	'class' => 'event_manager_questions_delete',
94 | 	'confirm' => elgg_echo('deleteconfirm'),
95 | 	'is_action' => false,
96 | ]);
97 | 
98 | echo elgg_view_image_block(elgg_view_icon('arrows-alt', ['class' => 'link']), $form_body, ['image_alt' => $delete_question]);
99 | 


--------------------------------------------------------------------------------
/views/default/groups/profile/module/event_manager.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Group event manager module
 4 |  */
 5 | 
 6 | $params = [
 7 | 	'title' => elgg_echo('event_manager:group'),
 8 | 	'entity_type' => 'object',
 9 | 	'entity_subtype' => 'event',
10 | ];
11 | $params = $params + $vars;
12 | 
13 | echo elgg_view('groups/profile/module', $params);
14 | 


--------------------------------------------------------------------------------
/views/default/icon/object/event.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $entity = elgg_extract('entity', $vars);
 4 | $size = elgg_extract('size', $vars, 'medium');
 5 | 
 6 | if ($size !== 'date') {
 7 | 	return;
 8 | }
 9 | 
10 | $event_start = $entity->getStartTimestamp();
11 | 
12 | $event_end = $entity->getEndTimestamp();
13 | if (($event_start < time()) && ($event_end > time())) {
14 | 	// show the running date
15 | 	$event_start = time();
16 | }
17 | 
18 | $month = elgg_format_element('div', ['class' => 'event_manager_event_list_icon_month'], strtoupper(trim(elgg_echo('date:month:short:' . date('m', $event_start), ['']))));
19 | $day = elgg_format_element('div', ['class' => 'event_manager_event_list_icon_day'], date('d', $event_start));
20 | 
21 | echo elgg_format_element('div', [
22 | 	'class' => 'event_manager_event_list_icon',
23 | 	'title' => event_manager_format_date($event_start),
24 | ], $month . $day);
25 | 


--------------------------------------------------------------------------------
/views/default/icon/object/eventregistration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Event registration user icon
 4 |  */
 5 | 
 6 | $entity = elgg_extract('entity', $vars);
 7 | if (!$entity instanceof \EventRegistration) {
 8 | 	return;
 9 | }
10 | 
11 | $size = elgg_extract('size', $vars, 'medium');
12 | if (!array_key_exists($size, elgg_get_icon_sizes('user'))) {
13 | 	$size = 'medium';
14 | }
15 | 
16 | $event = $entity->getOwnerEntity();
17 | 
18 | $name = htmlspecialchars($entity->getDisplayName(), ENT_QUOTES, 'UTF-8', false);
19 | $username = $entity->username;
20 | 
21 | $wrapper_class = [
22 | 	'elgg-avatar',
23 | 	"elgg-avatar-{$size}",
24 | ];
25 | $wrapper_class = elgg_extract_class($vars, $wrapper_class);
26 | 
27 | $icon = elgg_view('output/img', [
28 | 	'src' => $entity->getIconURL($size),
29 | 	'alt' => $name,
30 | 	'title' => $name,
31 | 	'class' => elgg_extract_class($vars, [], 'img_class'),
32 | ]);
33 | 
34 | $content = elgg_format_element('a', [], $icon);
35 | 
36 | echo elgg_format_element('div', ['class' => $wrapper_class], $content);
37 | 


--------------------------------------------------------------------------------
/views/default/object/event.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $event = elgg_extract('entity', $vars);
 4 | if (!$event instanceof \Event) {
 5 | 	return;
 6 | }
 7 | 
 8 | if ($event->owner_guid === elgg_get_logged_in_user_guid()) {
 9 | 	$vars['class'] = elgg_extract_class($vars, 'event-manager-event-owner');
10 | } elseif ($event->getRelationshipByUser()) {
11 | 	$vars['class'] = elgg_extract_class($vars, 'event-manager-event-attending');
12 | }
13 | 
14 | if (elgg_extract('full_view', $vars)) {
15 | 	echo elgg_view('event_manager/event/view', $vars);
16 | 	return;
17 | }
18 | 
19 | $content = '';
20 | 
21 | $excerpt = $event->getExcerpt();
22 | if ($excerpt) {
23 | 	$content .= elgg_format_element('div', [], $excerpt);
24 | }
25 | 
26 | $content .= elgg_view('event_manager/event/rsvp', $vars);
27 | 
28 | $imprint = elgg_extract('imprint', $vars, []);
29 | 
30 | $location = $event->location;
31 | if ($location) {
32 | 	$imprint['location'] = [
33 | 		'icon_name' => 'map-marker-alt',
34 | 		'content' => elgg_view_url($event->getURL() . '#location', $location),
35 | 	];
36 | }
37 | 
38 | $attendee_count = $event->countAttendees();
39 | if ($attendee_count > 0 || $event->openForRegistration()) {
40 | 	$imprint['attendee_count'] = [
41 | 		'icon_name' => 'users',
42 | 		'content' => elgg_echo('event_manager:event:relationship:event_attending:entity_menu', [$attendee_count]),
43 | 	];
44 | }
45 | 
46 | $params = [
47 | 	'entity' => $event,
48 | 	'content' => $content,
49 | 	'imprint' => $imprint,
50 | 	'time' => false,
51 | 	'icon' => elgg_view_entity_icon($event, 'date'),
52 | ];
53 | 
54 | $params = $params + $vars;
55 | 
56 | echo elgg_view('object/elements/summary', $params);
57 | 


--------------------------------------------------------------------------------
/views/default/object/eventregistration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Show an event registration object. This is a non-registered site user who registered to an event
 4 |  *
 5 |  * @uses $vars['entity'] EventRegistration the non-registered user
 6 |  */
 7 | 
 8 | $entity = elgg_extract('entity', $vars);
 9 | if (!$entity instanceof \EventRegistration) {
10 | 	return;
11 | }
12 | 
13 | $params = [
14 | 	'title' => $entity->getDisplayName(),
15 | 	'icon_entity' => $entity,
16 | 	'subtitle' => false,
17 | ];
18 | $params = $params + $vars;
19 | 
20 | echo elgg_view('object/elements/summary', $params);
21 | 


--------------------------------------------------------------------------------
/views/default/plugins/event_manager/settings.mjs:
--------------------------------------------------------------------------------
1 | import 'jquery';
2 | 
3 | $(document).on('change', 'select[name="params[maps_provider]"]', function() {
4 | 	var selected_value = $(this).val();
5 | 	
6 | 	$('.event-manager-maps-provider').hide();
7 | 	$('.event-manager-maps-provider-' + selected_value).show();
8 | });
9 | 


--------------------------------------------------------------------------------
/views/default/resources/event/add.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Elgg\Exceptions\Http\EntityPermissionsException;
 4 | 
 5 | $page_owner = elgg_get_page_owner_entity();
 6 | 
 7 | if (!$page_owner->canWriteToContainer(0, 'object', 'subtype')) {
 8 | 	throw new EntityPermissionsException();
 9 | }
10 | 
11 | elgg_push_collection_breadcrumbs('object', 'event', $page_owner);
12 | 
13 | echo elgg_view_page(elgg_echo('event_manager:edit:title'), [
14 | 	'content' => elgg_view_form('event_manager/event/edit', [
15 | 		'id' => 'event_manager_event_edit',
16 | 		'name' 	=> 'event_manager_event_edit',
17 | 	]),
18 | 	'filter_id' => 'event/edit',
19 | ]);
20 | 


--------------------------------------------------------------------------------
/views/default/resources/event/attendees.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Elgg\Exceptions\Http\BadRequestException;
 4 | 
 5 | $guid = elgg_extract('guid', $vars);
 6 | elgg_entity_gatekeeper($guid, 'object', \Event::SUBTYPE);
 7 | 
 8 | /* @var $entity \Event */
 9 | $entity = get_entity($guid);
10 | 
11 | $relationship = elgg_extract('relationship', $vars);
12 | $valid_relationships = $entity->getSupportedRelationships();
13 | if (!array_key_exists($relationship, $valid_relationships)) {
14 | 	$exception = new BadRequestException();
15 | 	$exception->setRedirectUrl(elgg_generate_url('collection:object:event:attendees', [
16 | 		'guid' => $entity->guid,
17 | 		'relationship' => EVENT_MANAGER_RELATION_ATTENDING,
18 | 	]));
19 | 	throw $exception;
20 | }
21 | 
22 | $rel_text = $valid_relationships[$relationship];
23 | 
24 | elgg_set_page_owner_guid($entity->container_guid);
25 | 
26 | elgg_push_entity_breadcrumbs($entity);
27 | 
28 | if ($entity->canEdit()) {
29 | 	elgg_register_menu_item('title', [
30 | 		'name' => 'export',
31 | 		'title' => elgg_echo('event_manager:event:exportattendees'),
32 | 		'icon' => 'download',
33 | 		'text' => elgg_echo('export'),
34 | 		'href' => elgg_generate_action_url('event_manager/attendees/export', [
35 | 			'guid' => $entity->guid,
36 | 			'rel' => $relationship,
37 | 		]),
38 | 		'link_class' => [
39 | 			'elgg-button',
40 | 			'elgg-button-action',
41 | 		],
42 | 	]);
43 | }
44 | 
45 | // search form
46 | $content = elgg_view_form('event_manager/event/attendees', [
47 | 	'action' => elgg_generate_url('collection:object:event:attendees', [
48 | 		'guid' => $entity->guid,
49 | 		'relationship' => $relationship,
50 | 	]),
51 | 	'method' => 'GET',
52 | 	'disable_security' => true,
53 | 	'prevent_double_submit' => false,
54 | ], [
55 | 	'entity' => $entity,
56 | 	'relationship' => $relationship,
57 | ]);
58 | 
59 | // attendees listing
60 | $content .= elgg_view('event_manager/event/attendees_list', [
61 | 	'entity' => $entity,
62 | 	'relationship' => $relationship,
63 | ]);
64 | 
65 | echo elgg_view_page(elgg_echo('event_manager:event:attendees:title', [$entity->getDisplayName(), $rel_text]), [
66 | 	'content' => $content,
67 | 	'filter_id' => 'event/attendees',
68 | 	'filter_value' => $relationship,
69 | 	'event_entity' => $entity,
70 | ]);
71 | 


--------------------------------------------------------------------------------
/views/default/resources/event/attending.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $user = elgg_get_page_owner_entity();
 4 | 
 5 | elgg_push_collection_breadcrumbs('object', 'event', $user);
 6 | 
 7 | $filter_value = ($user->guid === elgg_get_logged_in_user_guid()) ? 'attending' : '';
 8 | 
 9 | $list_type = get_input('list_type', 'list');
10 | 
11 | $content = elgg_view("event_manager/listing/{$list_type}", [
12 | 	'options' => [
13 | 		'metadata_name_value_pairs' => [
14 | 			[
15 | 				'name' => 'event_start',
16 | 				'value' => time(),
17 | 				'operand' => '>=',
18 | 			],
19 | 		],
20 | 		'sort_by' => [
21 | 			'property' => 'event_start',
22 | 			'direction' => 'ASC',
23 | 			'signed' => true,
24 | 		],
25 | 		'relationship' => EVENT_MANAGER_RELATION_ATTENDING,
26 | 		'relationship_guid' => $user->guid,
27 | 		'inverse_relationship' => true,
28 | 	],
29 | 	'resource' => 'attending',
30 | 	'page_owner' => $user,
31 | ]);
32 | 
33 | echo elgg_view_page(elgg_echo('event_manager:attending:title', [$user->getDisplayName()]), [
34 | 	'content' => $content,
35 | 	'filter_value' => $filter_value,
36 | 	'filter_id' => 'events',
37 | ]);
38 | 


--------------------------------------------------------------------------------
/views/default/resources/event/edit.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $guid = (int) elgg_extract('guid', $vars);
 4 | elgg_entity_gatekeeper($guid, 'object', \Event::SUBTYPE, true);
 5 | 
 6 | /* @var $event \Event */
 7 | $event = get_entity($guid);
 8 | 
 9 | elgg_set_page_owner_guid($event->container_guid);
10 | 
11 | elgg_push_entity_breadcrumbs($event);
12 | 
13 | elgg_register_menu_item('title', [
14 | 	'name' => 'copy',
15 | 	'icon' => 'clone-regular',
16 | 	'href' => 'ajax/form/event_manager/event/copy?guid=' . $event->guid,
17 | 	'text' => elgg_echo('event_manager:menu:copy'),
18 | 	'link_class' => 'elgg-lightbox elgg-button elgg-button-action',
19 | ]);
20 | 
21 | echo elgg_view_page(elgg_echo('event_manager:edit:title'), [
22 | 	'content' => elgg_view_form('event_manager/event/edit', [
23 | 		'id' => 'event_manager_event_edit',
24 | 		'name' 	=> 'event_manager_event_edit',
25 | 	], [
26 | 		'entity' => $event,
27 | 	]),
28 | 	'filter_id' => 'event/edit',
29 | ]);
30 | 


--------------------------------------------------------------------------------
/views/default/resources/event/edit_program.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $guid = (int) elgg_extract('guid', $vars);
 4 | elgg_entity_gatekeeper($guid, 'object', \Event::SUBTYPE, true);
 5 | 
 6 | /* @var $event \Event */
 7 | $event = get_entity($guid);
 8 | 
 9 | elgg_register_menu_item('title', [
10 | 	'name' => 'event',
11 | 	'href' => $event->getURL(),
12 | 	'icon_alt' => 'arrow-right',
13 | 	'text' => elgg_echo('event_manager:edit_program:continue'),
14 | 	'class' => ['elgg-button', 'elgg-button-action'],
15 | ]);
16 | 
17 | elgg_set_page_owner_guid($event->getContainerGUID());
18 | 
19 | elgg_push_entity_breadcrumbs($event);
20 | 
21 | $content = elgg_format_element('div', [], elgg_view('output/longtext', [
22 | 	'value' => elgg_echo('event_manager:edit_program:description'),
23 | 	'class' => 'mbm',
24 | ]));
25 | 
26 | $content .= elgg_view('event_manager/program/view', ['entity' => $event]);
27 | 
28 | echo elgg_view_page(elgg_echo('event_manager:edit_program:title'), [
29 | 	'content' => $content,
30 | 	'filter' => false,
31 | ]);
32 | 


--------------------------------------------------------------------------------
/views/default/resources/event/live.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $page_owner = elgg_get_page_owner_entity() ?: null;
 4 | if ($page_owner instanceof \ElggGroup) {
 5 | 	elgg_entity_gatekeeper($page_owner->guid, 'group');
 6 | 	elgg_group_tool_gatekeeper('event_manager');
 7 | 	
 8 | 	elgg_push_collection_breadcrumbs('object', \Event::SUBTYPE, $page_owner);
 9 | } else {
10 | 	$page_owner = null;
11 | 	elgg_set_page_owner_guid(0);
12 | }
13 | 
14 | elgg_register_title_button('add', 'object', \Event::SUBTYPE);
15 | 
16 | $list_type = get_input('list_type', 'list');
17 | 
18 | $content = elgg_view("event_manager/listing/{$list_type}", [
19 | 	'options' => [
20 | 		'container_guid' => ($page_owner instanceof ElggGroup) ? $page_owner->guid : ELGG_ENTITIES_ANY_VALUE,
21 | 		'metadata_name_value_pairs' => [
22 | 			[
23 | 				'name' => 'event_start',
24 | 				'value' => time(),
25 | 				'operand' => '<=',
26 | 			],
27 | 			[
28 | 				'name' => 'event_end',
29 | 				'value' => time(),
30 | 				'operand' => '>=',
31 | 			],
32 | 		],
33 | 		'sort_by' => [
34 | 			'property' => 'event_start',
35 | 			'direction' => 'ASC',
36 | 			'signed' => true,
37 | 		],
38 | 	],
39 | 	'resource' => 'live',
40 | 	'page_owner' => $page_owner,
41 | ]);
42 | 
43 | echo elgg_view_page(elgg_echo('event_manager:list:live'), [
44 | 	'content' => $content,
45 | 	'filter_id' => 'events',
46 | 	'filter_value' => 'live',
47 | ]);
48 | 


--------------------------------------------------------------------------------
/views/default/resources/event/mail.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Allow an event creator to mail the attendees of the event
 4 |  */
 5 | 
 6 | use ColdTrick\EventManager\Forms\EventMail;
 7 | use Elgg\Exceptions\Http\EntityNotFoundException;
 8 | use Elgg\Exceptions\Http\EntityPermissionsException;
 9 | 
10 | if (!(bool) elgg_get_plugin_setting('event_mail', 'event_manager')) {
11 | 	// feature not enabled
12 | 	throw new EntityNotFoundException();
13 | }
14 | 
15 | $guid = (int) elgg_extract('guid', $vars);
16 | elgg_entity_gatekeeper($guid, 'object', \Event::SUBTYPE);
17 | 
18 | /* @var $entity \Event */
19 | $entity = get_entity($guid);
20 | if (!$entity->canEdit()) {
21 | 	throw new EntityPermissionsException();
22 | }
23 | 
24 | elgg_set_page_owner_guid($entity->container_guid);
25 | 
26 | elgg_push_entity_breadcrumbs($entity);
27 | 
28 | $form = new EventMail($entity);
29 | 
30 | echo elgg_view_page(elgg_echo('event_manager:mail:title', [$entity->getDisplayName()]), [
31 | 	'content' => elgg_view_form('event_manager/event/mail', [], $form()),
32 | 	'filter_id' => 'events/mail',
33 | 	'filter_value' => 'mail',
34 | ]);
35 | 


--------------------------------------------------------------------------------
/views/default/resources/event/owner.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $user = elgg_get_page_owner_entity();
 4 | 
 5 | elgg_register_title_button('add', 'object', \Event::SUBTYPE);
 6 | 
 7 | elgg_push_collection_breadcrumbs('object', 'event', $user);
 8 | 
 9 | $list_type = get_input('list_type', 'list');
10 | 
11 | $content = elgg_view("event_manager/listing/{$list_type}", [
12 | 	'options' => [
13 | 		'owner_guid' => $user->guid,
14 | 	],
15 | 	'resource' => 'owner',
16 | 	'page_owner' => $user,
17 | ]);
18 | 
19 | echo elgg_view_page(elgg_echo('event_manager:owner:title', [$user->getDisplayName()]), [
20 | 	'content' => $content,
21 | 	'filter_value' => ($user->guid === elgg_get_logged_in_user_guid()) ? 'mine' : '',
22 | 	'filter_id' => 'events',
23 | ]);
24 | 


--------------------------------------------------------------------------------
/views/default/resources/event/register.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Elgg\Exceptions\Http\BadRequestException;
 4 | use Elgg\Exceptions\HttpException;
 5 | 
 6 | $guid = (int) elgg_extract('guid', $vars);
 7 | elgg_entity_gatekeeper($guid, 'object', Event::SUBTYPE);
 8 | 
 9 | /* @var $entity \Event */
10 | $event = get_entity($guid);
11 | 
12 | elgg_set_page_owner_guid($event->getContainerGUID());
13 | 
14 | if ((!$event->registration_needed && elgg_is_logged_in()) || (!elgg_is_logged_in() && !$event->register_nologin)) {
15 | 	$exception = new BadRequestException(elgg_echo('event_manager:registration:message:registrationnotneeded'));
16 | 	$exception->setRedirectUrl($event->getURL());
17 | 	throw $exception;
18 | }
19 | 
20 | if (!elgg_is_logged_in()) {
21 | 	if (!$event->hasEventSpotsLeft() || !$event->hasSlotSpotsLeft()) {
22 | 		if ($event->waiting_list_enabled && $event->registration_needed && $event->openForRegistration()) {
23 | 			$exception = new HttpException();
24 | 			$exception->setRedirectUrl(elgg_generate_url('collection:object:event:waitinglist', ['guid' => $guid]));
25 | 			throw $exception;
26 | 		} else {
27 | 			$exception = new BadRequestException(elgg_echo('event_manager:event:rsvp:nospotsleft'));
28 | 			$exception->setRedirectUrl(REFERRER);
29 | 			throw $exception;
30 | 		}
31 | 	}
32 | }
33 | 
34 | if (!$event->openForRegistration()) {
35 | 	$exception = new BadRequestException(elgg_echo('event_manager:event:rsvp:registration_ended'));
36 | 	$exception->setRedirectUrl($event->getURL());
37 | 	throw $exception;
38 | }
39 | 
40 | $form_vars = ['id' => 'event_manager_event_register', 'name' => 'event_manager_event_register'];
41 | 
42 | $form = elgg_view_form('event_manager/event/register', $form_vars, ['entity' => $event]);
43 | 
44 | $title_text = elgg_echo('event_manager:registration:register:title');
45 | 
46 | elgg_push_entity_breadcrumbs($event);
47 | 
48 | $title = $title_text . " '{$event->getDisplayName()}'";
49 | 
50 | echo elgg_view_page($title, [
51 | 	'content' => $form,
52 | 	'filter' => false,
53 | ]);
54 | 
55 | elgg_clear_sticky_form('event_register');
56 | 


--------------------------------------------------------------------------------
/views/default/resources/event/unsubscribe/confirm.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Elgg\Exceptions\Http\BadRequestException;
 4 | 
 5 | $guid = (int) elgg_extract('guid', $vars);
 6 | $code = elgg_extract('code', $vars);
 7 | 
 8 | elgg_entity_gatekeeper($guid, 'object', \EventRegistration::SUBTYPE);
 9 | $registration = get_entity($guid);
10 | 
11 | $event = $registration->getOwnerEntity();
12 | $verify_code = event_manager_create_unsubscribe_code($registration, $event);
13 | 
14 | if (empty($code) || ($code !== $verify_code)) {
15 | 	$exception = new BadRequestException(elgg_echo('event_manager:unsubscribe_confirm:error:code'));
16 | 	$exception->setRedirectUrl(REFERRER);
17 | 	throw $exception;
18 | }
19 | 
20 | elgg_set_page_owner_guid($event->getContainerGUID());
21 | 
22 | elgg_push_entity_breadcrumbs($event);
23 | 
24 | $body_vars = [
25 | 	'entity' => $event,
26 | 	'registration' => $registration,
27 | 	'code' => $code,
28 | ];
29 | $body = elgg_view_form('event_manager/event/unsubscribe_confirm', [], $body_vars);
30 | 
31 | echo elgg_view_page(elgg_echo('event_manager:unsubscribe_confirm:title', [$event->getDisplayName()]), [
32 | 	'content' => $body,
33 | 	'filter' => false,
34 | ]);
35 | 


--------------------------------------------------------------------------------
/views/default/resources/event/unsubscribe/request.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Elgg\Exceptions\Http\BadRequestException;
 4 | 
 5 | $guid = (int) elgg_extract('guid', $vars);
 6 | 
 7 | elgg_entity_gatekeeper($guid, 'object', \Event::SUBTYPE);
 8 | $entity = get_entity($guid);
 9 | 
10 | if (!$entity->register_nologin) {
11 | 	$exception = new BadRequestException();
12 | 	$exception->setRedirectUrl(REFERRER);
13 | 	throw $exception;
14 | }
15 | 
16 | elgg_set_page_owner_guid($entity->getContainerGUID());
17 | 
18 | elgg_push_entity_breadcrumbs($entity);
19 | 
20 | $body = elgg_view_form('event_manager/event/unsubscribe', [], ['entity' => $entity]);
21 | 
22 | echo elgg_view_page(elgg_echo('event_manager:unsubscribe:title', [$entity->getDisplayName()]), [
23 | 	'content' => $body,
24 | 	'filter' => false,
25 | ]);
26 | 


--------------------------------------------------------------------------------
/views/default/resources/event/upcoming.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $page_owner = elgg_get_page_owner_entity() ?: null;
 4 | if ($page_owner instanceof \ElggGroup) {
 5 | 	elgg_entity_gatekeeper($page_owner->guid, 'group');
 6 | 	elgg_group_tool_gatekeeper('event_manager');
 7 | 	
 8 | 	elgg_push_collection_breadcrumbs('object', \Event::SUBTYPE, $page_owner);
 9 | } else {
10 | 	$page_owner = null;
11 | 	elgg_set_page_owner_guid(0);
12 | }
13 | 
14 | elgg_register_title_button('add', 'object', \Event::SUBTYPE);
15 | 
16 | $list_type = get_input('list_type', 'list');
17 | 
18 | $content = elgg_view("event_manager/listing/{$list_type}", [
19 | 	'options' => [
20 | 		'container_guid' => ($page_owner instanceof \ElggGroup) ? $page_owner->guid : ELGG_ENTITIES_ANY_VALUE,
21 | 		'metadata_name_value_pairs' => [
22 | 			[
23 | 				'name' => 'event_start',
24 | 				'value' => time(),
25 | 				'operand' => '>=',
26 | 			],
27 | 		],
28 | 		'sort_by' => [
29 | 			'property' => 'event_start',
30 | 			'direction' => 'ASC',
31 | 			'signed' => true,
32 | 		],
33 | 	],
34 | 	'resource' => 'upcoming',
35 | 	'page_owner' => $page_owner,
36 | ]);
37 | 
38 | echo elgg_view_page(elgg_echo('event_manager:list:upcoming'), [
39 | 	'content' => $content,
40 | 	'filter_id' => 'events',
41 | 	'filter_value' => 'upcoming',
42 | ]);
43 | 


--------------------------------------------------------------------------------
/views/default/resources/event/upload.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $guid = (int) elgg_extract('guid', $vars);
 4 | elgg_entity_gatekeeper($guid, 'object', \Event::SUBTYPE, true);
 5 | 
 6 | /* @var $event \Event */
 7 | $event = get_entity($guid);
 8 | 
 9 | elgg_push_entity_breadcrumbs($event);
10 | 
11 | $form_vars = [
12 | 	'id' => 'event_manager_event_upload',
13 | 	'name' => 'event_manager_event_upload',
14 | 	'action' => 'action/event_manager/event/upload',
15 | 	'enctype' => 'multipart/form-data',
16 | ];
17 | 
18 | $content = elgg_view_form('event_manager/event/upload_file', $form_vars, ['entity' => $event]);
19 | 
20 | $content .= elgg_view('event_manager/event/files', ['entity' => $event]);
21 | 
22 | echo elgg_view_page(elgg_echo('event_manager:edit:upload:title'), [
23 | 	'content' => $content,
24 | 	'filter' => false,
25 | ]);
26 | 


--------------------------------------------------------------------------------
/views/default/resources/event/view.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $guid = (int) elgg_extract('guid', $vars);
 4 | elgg_entity_gatekeeper($guid, 'object', \Event::SUBTYPE);
 5 | 
 6 | /* @var $event \Event */
 7 | $event = get_entity($guid);
 8 | 
 9 | $show_add_to_calendar = elgg_get_plugin_setting('add_event_to_calendar', 'event_manager');
10 | if ($show_add_to_calendar === 'yes' || ($show_add_to_calendar === 'attendee_only' && !empty($event->getRelationshipByUser()))) {
11 | 	elgg_register_menu_item('title', [
12 | 		'name' => 'addthisevent',
13 | 		'href' => false,
14 | 		'icon' => 'calendar',
15 | 		'class' => 'elgg-button elgg-button-action',
16 | 		'text' => elgg_view('event_manager/addthisevent/button', ['entity' => $event]),
17 | 	]);
18 | }
19 | 
20 | elgg_push_entity_breadcrumbs($event);
21 | 
22 | echo elgg_view_page($event->getDisplayName(), [
23 | 	'content' => elgg_view_entity($event),
24 | 	'sidebar' => elgg_view('event_manager/event/sidebar', ['entity' => $event]),
25 | 	'entity' => $event,
26 | 	'filter_id' => 'event/view',
27 | ]);
28 | 


--------------------------------------------------------------------------------
/views/default/resources/event/waitinglist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Elgg\Exceptions\HttpException;
 4 | 
 5 | $guid = (int) elgg_extract('guid', $vars);
 6 | elgg_entity_gatekeeper($guid, 'object', \Event::SUBTYPE);
 7 | 
 8 | /* @var $event \Event */
 9 | $event = get_entity($guid);
10 | 
11 | elgg_set_page_owner_guid($event->getContainerGUID());
12 | 
13 | if (!$event->waiting_list_enabled) {
14 | 	$exception = new HttpException();
15 | 	$exception->setRedirectUrl($event->getURL());
16 | 	throw $exception;
17 | }
18 | 
19 | if (!$event->openForRegistration()) {
20 | 	$exception = new HttpException(elgg_echo('event_manager:event:rsvp:registration_ended'));
21 | 	$exception->setRedirectUrl($event->getURL());
22 | 	throw $exception;
23 | }
24 | 
25 | elgg_push_entity_breadcrumbs($event);
26 | 
27 | echo elgg_view_page(elgg_echo('event_manager:event:rsvp:waiting_list'), [
28 | 	'content' => elgg_view_form('event_manager/event/register', [
29 | 		'id' => 'event_manager_event_register',
30 | 		'name' => 'event_manager_event_register',
31 | 	], [
32 | 		'entity' => $event,
33 | 		'register_type' => 'waitinglist',
34 | 	]),
35 | 	'filter' => false,
36 | ]);
37 | 


--------------------------------------------------------------------------------
/views/default/resources/eventregistration/completed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Elgg\Exceptions\Http\BadRequestException;
 4 | 
 5 | $event_guid = (int) elgg_extract('event_guid', $vars);
 6 | $object_guid = (int) elgg_extract('object_guid', $vars); // user or registration object
 7 | 
 8 | elgg_entity_gatekeeper($event_guid, 'object', \Event::SUBTYPE);
 9 | 
10 | /* @var $event \Event */
11 | $event = get_entity($event_guid);
12 | 
13 | elgg_entity_gatekeeper($object_guid);
14 | $object = get_entity($object_guid);
15 | 
16 | if (!$object instanceof \ElggUser && !$object instanceof \EventRegistration) {
17 | 	$exception = new BadRequestException();
18 | 	$exception->setRedirectUrl(elgg_generate_url('collection:object:event:upcoming'));
19 | 	throw $exception;
20 | }
21 | 
22 | elgg_set_page_owner_guid($event->getContainerGUID());
23 | 
24 | elgg_push_entity_breadcrumbs($event);
25 | 
26 | echo elgg_view_page(elgg_echo('event_manager:registration:completed:title', [$event->getDisplayName()]), [
27 | 	'content' => elgg_view('event_manager/registration/completed', [
28 | 		'event' => $event,
29 | 		'object' => $object,
30 | 	]),
31 | 	'filter' => false,
32 | ]);
33 | 


--------------------------------------------------------------------------------
/views/default/resources/eventregistration/confirm.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Elgg\Exceptions\HttpException;
 4 | 
 5 | $event_guid = (int) elgg_extract('guid', $vars);
 6 | $user_guid = (int) elgg_extract('user_guid', $vars, get_input('user_guid'));
 7 | $code = elgg_extract('code', $vars, get_input('code'));
 8 | 
 9 | elgg_entity_gatekeeper($event_guid, 'object', \Event::SUBTYPE);
10 | 
11 | /* @var $event \Event */
12 | $event = get_entity($event_guid);
13 | 
14 | elgg_entity_gatekeeper($user_guid);
15 | $user = get_entity($user_guid);
16 | 
17 | // is the code valid
18 | if (!event_manager_validate_registration_validation_code($event_guid, $user_guid, $code)) {
19 | 	throw new HttpException(elgg_echo('event_manager:registration:confirm:error:code'), ELGG_HTTP_FORBIDDEN);
20 | }
21 | 
22 | // do we have a pending registration
23 | if ($event->getRelationshipByUser($user_guid) !== EVENT_MANAGER_RELATION_ATTENDING_PENDING) {
24 | 	$exception = new HttpException();
25 | 	$exception->setRedirectUrl($event->getURL());
26 | 	throw $exception;
27 | }
28 | 
29 | elgg_set_page_owner_guid($event->getContainerGUID());
30 | 
31 | elgg_push_entity_breadcrumbs($event);
32 | 
33 | echo elgg_view_page(elgg_echo('event_manager:registration:confirm:title', [$event->getDisplayName()]), [
34 | 	'content' => elgg_view_form('event_manager/registration/confirm', [], [
35 | 		'event' => $event,
36 | 		'user' => $user,
37 | 		'code' => $code,
38 | 	]),
39 | 	'filter' => false,
40 | ]);
41 | 


--------------------------------------------------------------------------------
/views/default/resources/eventregistration/view.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | use Elgg\Exceptions\HttpException;
 3 | 
 4 | $key = elgg_extract('k', $vars);
 5 | $guid = (int) elgg_extract('guid', $vars);
 6 | $user_guid = (int) elgg_extract('u_g', $vars, elgg_get_logged_in_user_guid());
 7 | 
 8 | elgg_entity_gatekeeper($guid, 'object', \Event::SUBTYPE);
 9 | 
10 | /* @var $event \Event */
11 | $event = get_entity($guid);
12 | 
13 | $output = '';
14 | $title_text = elgg_echo('event_manager:registration:registrationto') . " '{$event->getDisplayName()}'";
15 | 
16 | elgg_push_entity_breadcrumbs($event);
17 | 
18 | if (!empty($key)) {
19 | 	// registration of a non logged in user
20 | 	
21 | 	$entity = get_entity($user_guid);
22 | 	if (empty($entity)) {
23 | 		$exception = new HttpException();
24 | 		$exception->setRedirectUrl(elgg_generate_url('default:object:event'));
25 | 		throw $exception;
26 | 	}
27 | 	
28 | 	if (!elgg_build_hmac([$event->time_created, $user_guid])->matchesToken($key)) {
29 | 		$exception = new HttpException();
30 | 		$exception->setRedirectUrl(elgg_generate_url('default:object:event'));
31 | 		throw $exception;
32 | 	}
33 | 
34 | 	$output .= elgg_call(ELGG_IGNORE_ACCESS, function() use ($entity, $event) {
35 | 		
36 | 		$result = elgg_view('event_manager/event/pdf', ['entity' => $event]);
37 | 		$result .= elgg_view('event_manager/registration/user_data', [
38 | 			'event' => $event,
39 | 			'entity' => $entity,
40 | 		]);
41 | 	
42 | 		if ($event->with_program) {
43 | 			$result .= $event->getProgramData($entity->guid);
44 | 		}
45 | 		
46 | 		return $result;
47 | 	});
48 | } else {
49 | 	elgg_gatekeeper();
50 | 	
51 | 	if (!$event->canEdit() && ($user_guid !== elgg_get_logged_in_user_guid())) {
52 | 		$exception = new HttpException();
53 | 		$exception->setRedirectUrl(elgg_generate_url('default:object:event'));
54 | 		throw $exception;
55 | 	}
56 | 	
57 | 	$output .= elgg_view('event_manager/event/pdf', ['entity' => $event]);
58 | 	$output .= elgg_view('event_manager/registration/user_data', [
59 | 		'event' => $event,
60 | 		'entity' => elgg_get_logged_in_user_entity(),
61 | 	]);
62 | 
63 | 	if ($event->with_program) {
64 | 		$output .= $event->getProgramData($user_guid);
65 | 	}
66 | 
67 | 	if ($user_guid === elgg_get_logged_in_user_guid()) {
68 | 		elgg_register_menu_item('title', [
69 | 			'name' => 'edityourregistration',
70 | 			'icon' => 'edit',
71 | 			'text' => elgg_echo('event_manager:registration:edityourregistration'),
72 | 			'link_class' => 'elgg-button elgg-button-action',
73 | 			'href' => elgg_generate_url('default:object:event:register', [
74 | 				'guid' => $event->guid,
75 | 			]),
76 | 		]);
77 | 	}
78 | }
79 | 
80 | elgg_register_menu_item('title', [
81 | 	'name' => 'save_to_pdf',
82 | 	'icon' => 'download',
83 | 	'text' => elgg_echo('event_manager:registration:view:savetopdf'),
84 | 	'link_class' => 'elgg-button elgg-button-action',
85 | 	'href' => elgg_generate_action_url('event_manager/registration/pdf', [
86 | 		'k' => elgg_build_hmac([$event->time_created, $user_guid])->getToken(),
87 | 		'guid' => $guid,
88 | 		'u_g' => $user_guid,
89 | 	]),
90 | ]);
91 | 
92 | echo elgg_view_page($title_text, [
93 | 	'content' => $output,
94 | 	'filter' => false,
95 | ]);
96 | 


--------------------------------------------------------------------------------
/views/default/river/event_relationship/create.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $item = elgg_extract('item', $vars);
 4 | 
 5 | $user = $item->getSubjectEntity();
 6 | $event = $item->getObjectEntity();
 7 | 
 8 | $subject_url = elgg_view_entity_url($user);
 9 | $event_url = elgg_view_entity_url($event);
10 | 
11 | $relationtype = $event->getRelationshipByUser($user->guid);
12 | 
13 | echo elgg_view('river/elements/layout', [
14 | 	'item' => $item,
15 | 	'summary' => elgg_echo("event_manager:river:event_relationship:create:{$relationtype}", [$subject_url, $event_url]),
16 | 	'metadata' => elgg_view_menu('river', [
17 | 		'item' => $item,
18 | 		'prepare_dropdown' => true,
19 | 	]),
20 | ]);
21 | 


--------------------------------------------------------------------------------
/views/default/widgets/events/content.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /* @var $widget \ElggWidget */
  4 | $widget = elgg_extract('entity', $vars);
  5 | 
  6 | $num_display = (int) $widget->num_display;
  7 | if ($num_display < 1) {
  8 | 	$num_display = 5;
  9 | }
 10 | 
 11 | $event_options = [
 12 | 	'type' => 'object',
 13 | 	'subtype' => 'event',
 14 | 	'limit' => $num_display,
 15 | 	'pagination' => false,
 16 | 	'metadata_name_value_pairs' => [
 17 | 		[
 18 | 			'name' => 'event_start',
 19 | 			'value' => time(),
 20 | 			'operand' => '>=',
 21 | 		],
 22 | 	],
 23 | 	'sort_by' => [
 24 | 		'property' => 'event_start',
 25 | 		'direction' => 'ASC',
 26 | 		'signed' => true,
 27 | 	],
 28 | 	'no_results' => elgg_echo('event_manager:list:noresults'),
 29 | ];
 30 | 
 31 | $tag_filter = $widget->tag ? elgg_string_to_array($widget->tag)[0] : null;
 32 | 
 33 | $more_link = elgg_generate_url('collection:object:event:upcoming', [
 34 | 	'tag' => $tag_filter,
 35 | ]);
 36 | 
 37 | $group_route_name = 'collection:object:event:group';
 38 | 
 39 | if ($widget->event_status === 'live') {
 40 | 	$event_options['metadata_name_value_pairs'] = [
 41 | 		[
 42 | 			'name' => 'event_start',
 43 | 			'value' => time(),
 44 | 			'operand' => '<=',
 45 | 		],
 46 | 		[
 47 | 			'name' => 'event_end',
 48 | 			'value' => time(),
 49 | 			'operand' => '>=',
 50 | 		],
 51 | 	];
 52 | 	
 53 | 	$more_link = elgg_generate_url('collection:object:event:live');
 54 | 	$group_route_name = 'collection:object:event:live';
 55 | }
 56 | 
 57 | if (!empty($tag_filter)) {
 58 | 	$event_options['metadata_name_value_pairs'][] = [
 59 | 		'name' => 'tags',
 60 | 		'value' => $tag_filter,
 61 | 		'case_sensitive' => false,
 62 | 	];
 63 | }
 64 | 
 65 | $owner = $widget->getOwnerEntity();
 66 | 
 67 | switch ($widget->context) {
 68 | 	case 'groups':
 69 | 		$event_options['container_guid'] = $owner->guid;
 70 | 		$more_link = elgg_generate_url($group_route_name, [
 71 | 			'guid' => $owner->guid,
 72 | 			'tag' => $tag_filter,
 73 | 		]);
 74 | 		break;
 75 | 	case 'profile':
 76 | 	case 'dashboard':
 77 | 		switch ($widget->type_to_show) {
 78 | 			case 'owning':
 79 | 				$event_options['owner_guid'] = $owner->guid;
 80 | 				$more_link = elgg_generate_url('collection:object:event:owner', [
 81 | 					'username' => $owner->username,
 82 | 					'tag' => $tag_filter,
 83 | 				]);
 84 | 				break;
 85 | 			case 'attending':
 86 | 				$event_options['relationship'] = EVENT_MANAGER_RELATION_ATTENDING;
 87 | 				$event_options['relationship_guid'] = $owner->guid;
 88 | 				$event_options['inverse_relationship'] = true;
 89 | 				
 90 | 				$more_link = elgg_generate_url('collection:object:event:attending', [
 91 | 					'username' => $owner->username,
 92 | 					'tag' => $tag_filter,
 93 | 				]);
 94 | 				break;
 95 | 		}
 96 | 		break;
 97 | }
 98 | 
 99 | if ($widget->group_guid) {
100 | 	$event_options['container_guid'] = $widget->group_guid;
101 | }
102 | 
103 | $more_text = elgg_echo('event_manager:list:more');
104 | if (!empty($tag_filter)) {
105 | 	$more_text = elgg_echo('event_manager:list:more:with_tag', [$tag_filter]);
106 | }
107 | 
108 | $event_options['widget_more'] = elgg_view_url($more_link, $more_text);
109 | 
110 | echo elgg_list_entities($event_options);
111 | 


--------------------------------------------------------------------------------
/views/default/widgets/events/edit.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /* @var $widget \ElggWidget */
 4 | $widget = elgg_extract('entity', $vars);
 5 | 
 6 | echo elgg_view('object/widget/edit/num_display', [
 7 | 	'entity' => $widget,
 8 | 	'default' => 5,
 9 | ]);
10 | 
11 | if (in_array($widget->context, ['dashboard', 'profile'])) {
12 | 	echo elgg_view_field([
13 | 		'#type' => 'select',
14 | 		'#label' => elgg_echo('widgets:events:showevents'),
15 | 		'name' => 'params[type_to_show]',
16 | 		'value' => $widget->type_to_show,
17 | 		'options_values' => [
18 | 			'all' => elgg_echo('all'),
19 | 			'owning' => elgg_echo('widgets:events:showevents:icreated'),
20 | 			'attending' => elgg_echo('widgets:events:showevents:attendingto'),
21 | 		],
22 | 	]);
23 | } else {
24 | 	echo elgg_view_field([
25 | 		'#type' => 'select',
26 | 		'#label' => elgg_echo('widgets:events:showevents:status'),
27 | 		'name' => 'params[event_status]',
28 | 		'value' => $widget->event_status,
29 | 		'options_values' => [
30 | 			'upcoming' => elgg_echo('event_manager:list:upcoming'),
31 | 			'live' => elgg_echo('event_manager:list:live'),
32 | 		],
33 | 	]);
34 | }
35 | 
36 | echo elgg_view_field([
37 | 	'#type' => 'text',
38 | 	'#label' => elgg_echo('widgets:events:tag_filter'),
39 | 	'#help' => elgg_echo('widgets:events:tag_filter:help'),
40 | 	'name' => 'params[tag]',
41 | 	'value' => $widget->tag,
42 | 
43 | ]);
44 | 
45 | if (!$widget->getOwnerEntity() instanceof \ElggSite) {
46 | 	// profile, dashboard, groups
47 | 	return;
48 | }
49 | 
50 | echo elgg_view_field([
51 | 	'#type' => 'grouppicker',
52 | 	'#label' => elgg_echo('widgets:events:group'),
53 | 	'name' => 'params[group_guid]',
54 | 	'values' => $widget->group_guid,
55 | 	'limit' => 1,
56 | ]);
57 | 


--------------------------------------------------------------------------------
/views/default/widgets/highlighted_events/content.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /* @var $widget \ElggWidget */
 4 | $widget = elgg_extract('entity', $vars);
 5 | $event_guids = $widget->event_guids;
 6 | $show_past_events = (bool) $widget->show_past_events;
 7 | 
 8 | if (empty($event_guids)) {
 9 | 	echo elgg_echo('event_manager:list:noresults');
10 | 	return;
11 | }
12 | 
13 | $event_guids = (array) $event_guids;
14 | 
15 | $events = [];
16 | 
17 | $entities = elgg_get_entities([
18 | 	'type' => 'object',
19 | 	'subtype' => \Event::SUBTYPE,
20 | 	'guids' => $event_guids,
21 | 	'limit' => false,
22 | ]);
23 | 
24 | foreach ($entities as $event) {
25 | 	if (!$show_past_events) {
26 | 		if ($event->getEndTimestamp() < time()) {
27 | 			continue;
28 | 		}
29 | 	}
30 | 	
31 | 	$events[$event->guid] = $event;
32 | }
33 | 
34 | $sorted_entities = [];
35 | foreach ($event_guids as $guid) {
36 | 	$entity = elgg_extract($guid, $events);
37 | 	if (!$entity) {
38 | 		continue;
39 | 	}
40 | 	
41 | 	$sorted_entities[] = $entity;
42 | }
43 | 
44 | echo elgg_view_entity_list($sorted_entities, [
45 | 	'full_view' => false,
46 | 	'pagination' => false,
47 | 	'limit' => false,
48 | 	'no_results' => elgg_echo('event_manager:list:noresults'),
49 | ]);
50 | 


--------------------------------------------------------------------------------
/views/default/widgets/highlighted_events/edit.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /* @var $widget \ElggWidget */
 4 | $widget = elgg_extract('entity', $vars);
 5 | 
 6 | echo elgg_view_field([
 7 | 	'#type' => 'objectpicker',
 8 | 	'#label' => elgg_echo('widgets:highlighted_events:edit:event_guids'),
 9 | 	'#help' => elgg_echo('widgets:highlighted_events:description'),
10 | 	'values' => $widget->event_guids,
11 | 	'name' => 'params[event_guids]',
12 | 	'subtype' => Event::SUBTYPE,
13 | 	'sortable' => true,
14 | ]);
15 | 
16 | echo elgg_view_field([
17 | 	'#type' => 'checkbox',
18 | 	'#label' => elgg_echo('widgets:highlighted_events:edit:show_past_events'),
19 | 	'name' => 'params[show_past_events]',
20 | 	'value' => 1,
21 | 	'checked' => (bool) $widget->show_past_events,
22 | 	'switch' => true,
23 | ]);
24 | ?>
25 | <script>
26 | 	$(document).ready(function() {
27 | 		$('#widget-edit-<?php echo $widget->guid; ?> ul.elgg-entity-picker-list').sortable();
28 | 	});
29 | </script>
30 | 


--------------------------------------------------------------------------------