class EventMeta in RNG - Events and Registrations 3.x
Same name and namespace in other branches
- 8.2 src/EventMeta.php \Drupal\rng\EventMeta
- 8 src/EventMeta.php \Drupal\rng\EventMeta
Meta event wrapper for RNG.
Hierarchy
- class \Drupal\rng\EventMeta implements EventMetaInterface
Expanded class hierarchy of EventMeta
File
- src/
EventMeta.php, line 22
Namespace
Drupal\rngView source
class EventMeta implements EventMetaInterface {
/**
* The entity query factory.
*
* @var \Drupal\Core\Entity\EntityInterface
*/
protected $entity;
/**
* The entity manager.
*
* @var \Drupal\Core\Entity\EntityTypeManagerInterface
*/
protected $entityManager;
/**
* @var \Drupal\Core\Entity\EntityTypeBundleInfoInterface
*/
protected $bundleInfo;
/**
* The config factory service.
*
* @var \Drupal\Core\Config\ConfigFactoryInterface
*/
protected $configFactory;
/**
* The selection plugin manager.
*
* @var \Drupal\Core\Entity\EntityReferenceSelection\SelectionPluginManagerInterface
*/
protected $selectionPluginManager;
/**
* The identity channel manager.
*
* @var \Drupal\courier\Service\IdentityChannelManagerInterface
*/
protected $identityChannelManager;
/**
* The RNG configuration service.
*
* @var \Drupal\rng\RngConfigurationInterface
*/
protected $rngConfiguration;
/**
* The RNG event manager.
*
* @var \Drupal\rng\EventManagerInterface
*/
protected $eventManager;
/**
* The courier manager.
*
* @var \Drupal\courier\Service\CourierManagerInterface
*/
protected $courier_manager;
/**
* The action manager.
*
* @var \Drupal\Core\Action\ActionManager
*/
protected $action_manager;
/**
* Constructs a new EventMeta object.
*
* @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_manager
* The entity manager.
* @param EntityTypeBundleInfoInterface $bundle_info
* The bundle info.
* @param \Drupal\Core\Config\ConfigFactoryInterface $config_factory
* The config factory service.
* @param \Drupal\Core\Entity\EntityReferenceSelection\SelectionPluginManagerInterface $selection_plugin_manager
* The selection plugin manager.
* @param \Drupal\courier\Service\IdentityChannelManagerInterface $identity_channel_manager
* The identity channel manager.
* @param \Drupal\rng\RngConfigurationInterface $rng_configuration
* The RNG configuration service.
* @param \Drupal\rng\EventManagerInterface $event_manager
* The RNG event manager.
* @param \Drupal\courier\Service\CourierManagerInterface $courier_manager
* The courier manager.
* @param \Drupal\Core\Action\ActionManager $action_manager
* The action manager.
* @param \Drupal\Core\Entity\EntityInterface $entity
* The event entity.
*/
public function __construct(EntityTypeManagerInterface $entity_manager, EntityTypeBundleInfoInterface $bundle_info, ConfigFactoryInterface $config_factory, SelectionPluginManagerInterface $selection_plugin_manager, IdentityChannelManagerInterface $identity_channel_manager, RngConfigurationInterface $rng_configuration, EventManagerInterface $event_manager, CourierManagerInterface $courier_manager, ActionManager $action_manager, EntityInterface $entity) {
$this->entityManager = $entity_manager;
$this->bundleInfo = $bundle_info;
$this->configFactory = $config_factory;
$this->selectionPluginManager = $selection_plugin_manager;
$this->identityChannelManager = $identity_channel_manager;
$this->rngConfiguration = $rng_configuration;
$this->eventManager = $event_manager;
$this->courier_manager = $courier_manager;
$this->action_manager = $action_manager;
$this->entity = $entity;
}
/**
* {@inheritdoc}
*/
public static function createInstance(ContainerInterface $container, EntityInterface $entity) {
return new static($container
->get('entity_type.manager'), $container
->get('entity_type.bundle.info'), $container
->get('config.factory'), $container
->get('plugin.manager.entity_reference_selection'), $container
->get('plugin.manager.identity_channel'), $container
->get('rng.configuration'), $container
->get('rng.event_manager'), $container
->get('courier.manager'), $container
->get('plugin.manager.action'), $entity);
}
/**
* {@inheritdoc}
*/
public function getEvent() {
return $this->entity;
}
/**
* {@inheritdoc}
*/
public function getEventType() {
return $this->eventManager
->eventType($this->entity
->getEntityTypeId(), $this->entity
->bundle());
}
/**
* {@inheritdoc}
*/
public function isAcceptingRegistrations() {
return !empty($this
->getEvent()->{EventManagerInterface::FIELD_STATUS}->value);
}
/**
* {@inheritdoc}
*/
public function getReplyTo() {
return $this
->getEvent()->{EventManagerInterface::FIELD_EMAIL_REPLY_TO}->value;
}
/**
* {@inheritdoc}
*/
public function duplicateRegistrantsAllowed() {
return !empty($this
->getEvent()->{EventManagerInterface::FIELD_ALLOW_DUPLICATE_REGISTRANTS}->value);
}
/**
* {@inheritdoc}
*/
public function getRegistrationTypeIds() {
return array_map(function ($element) {
return isset($element['target_id']) ? $element['target_id'] : [];
}, $this
->getEvent()->{EventManagerInterface::FIELD_REGISTRATION_TYPE}
->getValue());
}
/**
* {@inheritdoc}
*/
public function getRegistrationTypes() {
return $this->entityManager
->getStorage('registration_type')
->loadMultiple($this
->getRegistrationTypeIds());
}
/**
* {@inheritdoc}
*/
public function registrationTypeIsValid(RegistrationTypeInterface $registration_type) {
return in_array($registration_type
->id(), $this
->getRegistrationTypeIds());
}
/**
* {@inheritdoc}
*/
public function removeRegistrationType($registration_type_id) {
/** @var \Drupal\Core\Field\FieldItemListInterface $registration_types */
$registration_types =& $this->entity->{EventManagerInterface::FIELD_REGISTRATION_TYPE};
foreach ($registration_types
->getValue() as $key => $value) {
if ($value['target_id'] == $registration_type_id) {
$registration_types
->removeItem($key);
}
}
return $this->entity;
}
/**
* {@inheritdoc}
*/
public function removeGroup($group_id) {
/** @var \Drupal\Core\Field\FieldItemListInterface $groups */
$groups =& $this->entity->{EventManagerInterface::FIELD_REGISTRATION_GROUPS};
foreach ($groups
->getValue() as $key => $value) {
if ($value['target_id'] == $group_id) {
$groups
->removeItem($key);
}
}
return $this->entity;
}
/**
* {@inheritdoc}
*/
public function getRegistrantCapacity() {
$capacity = (int) $this
->getEvent()->{EventManagerInterface::FIELD_REGISTRANTS_CAPACITY}->value;
if ($capacity != '' && is_numeric($capacity) && $capacity >= 0) {
return $capacity;
}
return EventMetaInterface::CAPACITY_UNLIMITED;
}
/**
* {@inheritdoc}
*/
public function remainingRegistrantCapacity() {
$capacity = $this
->getRegistrantCapacity();
if ($capacity == EventMetaInterface::CAPACITY_UNLIMITED) {
return $capacity;
}
$remaining = $capacity - $this
->countRegistrants();
return $remaining > 0 ? $remaining : 0;
}
/**
* {@inheritdoc}
*/
public function allowWaitList() {
return (bool) $this
->getEvent()->{EventManagerInterface::FIELD_WAIT_LIST}->value;
}
/**
* {@inheritdoc}
*/
public function getRegistrantsMaximum() {
if (isset($this
->getEvent()->{EventManagerInterface::FIELD_REGISTRANTS_CAPACITY})) {
$field = $this
->getEvent()->{EventManagerInterface::FIELD_REGISTRANTS_CAPACITY};
$maximum = $field->value;
if ($maximum !== '' && is_numeric($maximum) && $maximum >= 0) {
return $maximum;
}
}
return EventMetaInterface::CAPACITY_UNLIMITED;
}
/**
* {@inheritdoc}
*/
public function getDefaultGroups() {
$groups = [];
foreach ($this
->getEvent()->{EventManagerInterface::FIELD_REGISTRATION_GROUPS} as $group) {
$groups[] = $group->entity;
}
return $groups;
}
/**
* {@inheritdoc}
*/
public function buildQuery($entity_type) {
return $this->entityManager
->getStorage($entity_type)
->getQuery('AND')
->condition('event__target_type', $this
->getEvent()
->getEntityTypeId(), '=')
->condition('event__target_id', $this
->getEvent()
->id(), '=');
}
/**
* {@inheritdoc}
*/
public function buildEventRegistrantQuery() {
$query = \Drupal::database()
->select('registrant', 'ant');
$query
->join('registration', 'ion', 'ion.id = ant.registration');
$query
->join('registration_field_data', 'rfd', 'ion.id = rfd.id');
$query
->fields('ant', [
'id',
]);
$query
->condition('rfd.event__target_type', $this
->getEvent()
->getEntityTypeId(), '=');
$query
->condition('rfd.event__target_id', $this
->getEvent()
->id(), '=');
return $query;
}
/**
* {@inheritdoc}
*/
public function buildRegistrationQuery() {
return $this
->buildQuery('registration');
}
/**
* {@inheritdoc}
*/
public function getRegistrations() {
$query = $this
->buildRegistrationQuery();
return $this->entityManager
->getStorage('registration')
->loadMultiple($query
->execute());
}
/**
* {@inheritdoc}
*/
public function countRegistrants() {
return $this
->buildEventRegistrantQuery()
->countQuery()
->execute()
->fetchField();
}
/**
* {@inheritdoc}
*/
public function countRegistrations() {
return $this
->buildRegistrationQuery()
->count()
->execute();
}
/**
* {@inheritdoc}
*/
public function buildRuleQuery() {
return $this
->buildQuery('rng_rule');
}
/**
* {@inheritdoc}
*/
public function getRules($trigger = NULL, $defaults = FALSE, $is_active = TRUE) {
$query = $this
->buildRuleQuery();
if ($trigger) {
$query
->condition('trigger_id', $trigger, '=');
}
if (isset($is_active)) {
$query
->condition('status', $is_active, '=');
}
$rules = $this->entityManager
->getStorage('rng_rule')
->loadMultiple($query
->execute());
if ($defaults && !$rules) {
return $this
->getDefaultRules($trigger);
}
return $rules;
}
/**
* {@inheritdoc}
*/
public function getDefaultRules($trigger = NULL) {
$rules = [];
if ($trigger != 'rng_event.register') {
return $rules;
}
/** @var \Drupal\rng\Entity\EventTypeRuleInterface[] $default_rules */
$default_rules = $this->entityManager
->getStorage('rng_event_type_rule')
->loadByProperties([
'entity_type' => $this
->getEvent()
->getEntityTypeId(),
'bundle' => $this
->getEvent()
->bundle(),
'trigger' => $trigger,
]);
foreach ($default_rules as $default_rule) {
$rule = Rule::create([
'event' => [
'entity' => $this
->getEvent(),
],
'trigger_id' => $trigger,
'status' => TRUE,
]);
foreach ($default_rule
->getConditions() as $condition) {
$plugin_id = $condition['id'];
unset($condition['id']);
$component = RuleComponent::create()
->setType('condition')
->setPluginId($plugin_id)
->setConfiguration($condition);
$rule
->addComponent($component);
}
foreach ($default_rule
->getActions() as $action) {
$component = RuleComponent::create()
->setType('action')
->setPluginId($action['id'])
->setConfiguration($action['configuration']);
$rule
->addComponent($component);
}
$rules[] = $rule;
}
return $rules;
}
/**
* {@inheritdoc}
*/
public function isDefaultRules($trigger) {
return (bool) (!$this
->getRules($trigger));
}
/**
* {@inheritdoc}
*/
public function trigger($trigger, $context = []) {
$context['event'] = $this
->getEvent();
foreach ($this
->getRules($trigger) as $rule) {
if ($rule
->evaluateConditions()) {
foreach ($rule
->getActions() as $action) {
$action
->execute($context);
}
}
}
}
/**
* {@inheritdoc}
*/
public function buildGroupQuery() {
return $this
->buildQuery('registration_group');
}
/**
* {@inheritdoc}
*/
public function getGroups() {
$query = $this
->buildGroupQuery();
return $this->entityManager
->getStorage('registration_group')
->loadMultiple($query
->execute());
}
/**
* {@inheritdoc}
*/
public function buildRegistrantQuery($entity_type_id = NULL) {
$query = $this->entityManager
->getStorage('registrant')
->getQuery('AND')
->condition('registration.entity.event__target_type', $this
->getEvent()
->getEntityTypeId(), '=')
->condition('registration.entity.event__target_id', $this
->getEvent()
->id(), '=');
if ($entity_type_id) {
$query
->condition('identity__target_type', $entity_type_id, '=');
}
return $query;
}
/**
* {@inheritdoc}
*/
public function getRegistrants($entity_type_id = NULL) {
$query = $this
->buildRegistrantQuery($entity_type_id);
return $this->entityManager
->getStorage('registrant')
->loadMultiple($query
->execute());
}
/**
* {@inheritdoc}
*/
public function canRegisterProxyIdentities() {
// Create is checked first since it is usually the cheapest.
$identity_types = $this
->getCreatableIdentityTypes();
foreach ($identity_types as $entity_type_id => $bundles) {
$accessControl = $this->entityManager
->getAccessControlHandler($entity_type_id);
if ($this
->entityTypeHasBundles($entity_type_id)) {
foreach ($bundles as $bundle) {
if ($accessControl
->createAccess($bundle)) {
return TRUE;
}
}
}
elseif (!empty($bundles)) {
if ($accessControl
->createAccess()) {
return TRUE;
}
}
}
// Reference existing.
$identity_types = $this
->getIdentityTypes();
foreach ($identity_types as $entity_type_id => $bundles) {
$referencable_bundles = $this
->entityTypeHasBundles($entity_type_id) ? $bundles : [];
$count = $this
->countRngReferenceableEntities($entity_type_id, $referencable_bundles);
if ($count > 0) {
return TRUE;
}
}
return FALSE;
}
/**
* {@inheritdoc}
*/
public function countProxyIdentities() {
$total = 0;
foreach ($this
->getIdentityTypes() as $entity_type_id => $bundles) {
if ($this
->entityTypeHasBundles($entity_type_id)) {
$total += $this
->countRngReferenceableEntities($entity_type_id, $bundles);
}
elseif (!empty($bundles)) {
$total += $this
->countRngReferenceableEntities($entity_type_id);
}
}
return $total;
}
/**
* Count referencable entities using a rng_register entity selection plugin.
*
* @param string $entity_type_id
* An identity entity type ID.
* @param array $bundles
* (optional) An array of bundles.
*
* @return int
* The number of referencable entities.
*/
protected function countRngReferenceableEntities($entity_type_id, $bundles = []) {
$selection_groups = $this->selectionPluginManager
->getSelectionGroups($entity_type_id);
if (isset($selection_groups['rng_register'])) {
$options = [
'target_type' => $entity_type_id,
'handler' => 'rng_register',
'handler_settings' => [
'event_entity_type' => $this
->getEvent()
->getEntityTypeId(),
'event_entity_id' => $this
->getEvent()
->id(),
],
];
if (!empty($bundles)) {
$options['handler_settings']['target_bundles'] = $bundles;
}
return $this->selectionPluginManager
->getInstance($options)
->countReferenceableEntities();
}
return 0;
}
/**
* {@inheritdoc}
*/
public function getIdentityTypes() {
$event_type = $this
->getEventType();
$result = [];
$identity_types_available = $this->rngConfiguration
->getIdentityTypes();
foreach ($identity_types_available as $entity_type_id) {
$bundles = $this->bundleInfo
->getBundleInfo($entity_type_id);
foreach ($bundles as $bundle => $info) {
if ($event_type
->canIdentityTypeReference($entity_type_id, $bundle)) {
$result[$entity_type_id][] = $bundle;
}
}
}
return $result;
}
/**
* {@inheritdoc}
*/
public function getCreatableIdentityTypes() {
$event_type = $this
->getEventType();
$result = [];
$identity_types_available = $this->rngConfiguration
->getIdentityTypes();
foreach ($identity_types_available as $entity_type_id) {
$bundles = $this->bundleInfo
->getBundleInfo($entity_type_id);
foreach ($bundles as $bundle => $info) {
if ($event_type
->canIdentityTypeCreate($entity_type_id, $bundle)) {
$result[$entity_type_id][] = $bundle;
}
}
}
return $result;
}
/**
* {@inheritdoc}
*/
public function identitiesCanRegister($entity_type, array $entity_ids) {
$identity_types = $this
->getIdentityTypes();
if (isset($identity_types[$entity_type])) {
$options = [
'target_type' => $entity_type,
'handler' => 'rng_register',
'handler_settings' => [
'event_entity_type' => $this
->getEvent()
->getEntityTypeId(),
'event_entity_id' => $this
->getEvent()
->id(),
],
];
if ($this
->entityTypeHasBundles($entity_type)) {
$options['handler_settings']['target_bundles'] = $identity_types[$entity_type];
}
/* @var $selection \Drupal\Core\Entity\EntityReferenceSelection\SelectionInterface */
$selection = $this->selectionPluginManager
->getInstance($options);
return $selection
->validateReferenceableEntities($entity_ids);
}
return [];
}
/**
* {@inheritdoc}
*/
public function addDefaultAccess() {
$rules = $this
->getDefaultRules('rng_event.register');
foreach ($rules as $rule) {
$rule
->save();
}
}
/**
* Determine whether an entity type uses a separate bundle entity type.
*
* @param string $entity_type_id
* An entity type Id.
*
* @return bool
* Whether an entity type uses a separate bundle entity type.
*/
protected function entityTypeHasBundles($entity_type_id) {
$entity_type = $this->entityManager
->getDefinition($entity_type_id);
return $entity_type
->getBundleEntityType() !== NULL;
}
/**
* {@inheritdoc}
*/
public function createDefaultEventMessages() {
// Get Default messages for this Event type.
$default_messages = $this
->getEventType()
->getDefaultMessages();
if ($default_messages) {
foreach ($default_messages as $default_message) {
// Create Event Messages from Default Messages.
$template_collection = TemplateCollection::create();
$template_collection
->save();
$this->courier_manager
->addTemplates($template_collection);
$template_collection
->setOwner($this
->getEvent());
$template_collection
->save();
$templates = $template_collection
->getTemplates();
/** @var \Drupal\courier\EmailInterface $courier_email */
$courier_email = $templates[0];
$courier_email
->setSubject($default_message['subject']);
$courier_email
->setBody($default_message['body']);
$courier_email
->save();
$rule = Rule::create([
'event' => [
'entity' => $this
->getEvent(),
],
'trigger_id' => $default_message['trigger'],
]);
$rule
->setIsActive($default_message['status']);
$actionPlugin = $this->action_manager
->createInstance('rng_courier_message');
$configuration = $actionPlugin
->getConfiguration();
$configuration['template_collection'] = $template_collection
->id();
$action = RuleComponent::create([])
->setPluginId($actionPlugin
->getPluginId())
->setConfiguration($configuration)
->setType('action');
$rule
->addComponent($action);
$rule
->save();
// Handle custom date trigger.
if ($default_message['trigger'] == 'rng:custom:date') {
$rule_component = RuleComponent::create()
->setRule($rule)
->setType('condition')
->setPluginId('rng_rule_scheduler');
$rule_component
->save();
// Save the ID into config.
$rule_component
->setConfiguration([
'rng_rule_component' => $rule_component
->id(),
]);
$rule_component
->save();
}
}
}
}
/**
* @inheritDoc
*/
public function getDateString() {
$event_type = $this
->getEventType();
$start_field = $event_type
->getEventStartDateField();
$end_field = $event_type
->getEventEndDateField();
$event = $this
->getEvent();
$start = $event
->get($start_field)->value;
$count = $event
->get($end_field)
->count();
$end_value = $event
->get($end_field)
->get($count - 1);
if (!empty($end_value->end_value)) {
$end = $end_value->end_value;
}
else {
$end = $end_value->value;
}
$start_date = date('F j, Y', strtotime($start));
$end_date = date('F j, Y', strtotime($end));
if ($start_date == $end_date) {
return $start_date;
}
return date('F j', strtotime($start)) . ' - ' . date('j, Y', strtotime($end));
}
/**
* @inheritDoc
*/
public function isPastEvent($use_end_date = FALSE) {
$event_type = $this
->getEventType();
$event = $this
->getEvent();
if ($use_end_date) {
$end_field = $event_type
->getEventEndDateField();
$count = $event
->get($end_field)
->count();
$end_value = $event
->get($end_field)
->get($count - 1);
if (!empty($end_value->end_value)) {
$compare_date = $end_value->end_value;
}
else {
$compare_date = $end_value->value;
}
}
else {
$start_field = $event_type
->getEventStartDateField();
$compare_date = $event
->get($start_field)->value;
}
return strtotime($compare_date) < time();
}
}
Members
Name | Modifiers | Type | Description | Overrides |
---|---|---|---|---|
EventMeta:: |
protected | property | The action manager. | |
EventMeta:: |
protected | property | ||
EventMeta:: |
protected | property | The config factory service. | |
EventMeta:: |
protected | property | The courier manager. | |
EventMeta:: |
protected | property | The entity query factory. | |
EventMeta:: |
protected | property | The entity manager. | |
EventMeta:: |
protected | property | The RNG event manager. | |
EventMeta:: |
protected | property | The identity channel manager. | |
EventMeta:: |
protected | property | The RNG configuration service. | |
EventMeta:: |
protected | property | The selection plugin manager. | |
EventMeta:: |
public | function |
Clones the site default access rules onto the event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Checks if a registrant is allowed to register on a wait list on this event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Builds a entity query for registrants with conditions referencing this
event via the registration entity. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Builds a entity query for groups with conditions referencing this event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Builds a entity query with conditions referencing this event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Builds a entity query for registrants associated to registrations
referencing this event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Builds a entity query for registrations with conditions referencing this
event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Builds a entity query for rules with conditions referencing this event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Determine if the current user has proxy register access. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Count number of identities the current user has proxy register access. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function | ||
EventMeta:: |
public | function |
Count how many registrations are on this event. Overrides EventMetaInterface:: |
|
EventMeta:: |
protected | function | Count referencable entities using a rng_register entity selection plugin. | |
EventMeta:: |
public | function |
Create messages for Event from Default messages for this Event Type. Overrides EventMetaInterface:: |
|
EventMeta:: |
public static | function |
Instantiates a new instance of EventMeta handler. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Checks if a registrant is allowed to register more than once on this event. Overrides EventMetaInterface:: |
|
EventMeta:: |
protected | function | Determine whether an entity type uses a separate bundle entity type. | |
EventMeta:: |
public | function |
Get identity types which can be created for this event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
@inheritDoc Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Get groups that should be added to all new registrations. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Gets site default access rules and associated conditions and actions. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Get the event entity. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Get the event type for the event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Get all groups for this event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Get identity types which can be referenced for this event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Gets configuration for maximum permitted registrants on this event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Get all registrants for this event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function | ||
EventMeta:: |
public | function |
Get all registrations for this event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Gets a list of registration types IDs allowed for this event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Gets a list of registration types allowed for this event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Get the reply-to e-mail address for mails sent from this event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Get all rules for this event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Determine if identities can register. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Checks if this event is accepting new registrations. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Determines if this event should use site default rules. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
@inheritDoc Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Checks if a registration type is allowed to be used on an event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Calculates how many more registrants can be added to this event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Removes references to a default group from the event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Removes references to an allowed registration type from the event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function |
Manually triggers rules for this event. Overrides EventMetaInterface:: |
|
EventMeta:: |
public | function | Constructs a new EventMeta object. | |
EventMetaInterface:: |
constant | Value indicating unlimited registration capacity for an event. |