Event Type Config getter method

Return event type configuration from ObjectFactory

@return \Cake\Http\Response|void|null
517179
public function eventTypeConfig()
    {
        $this->request->allowMethod(['post', 'put', 'patch']);

        $response = [
            'success' => false,
            'data' => [],
            'errors' => [],
        ];

        $data = $this->request->getData();

        try {
            $config = ObjectFactory::getConfig(null, 'Event', $data['event_type']);

            if (!empty($config)) {
                $response['success'] = true;
                $response['data'] = $config;
            }
        } catch (Exception $e) {
            $response['errors'][] = $e->getMessage();
            throw $e;
        }

        $this->set(compact('response'));
        $this->set('_serialize', 'response');
    }
372530
public function getContainer()
    {
        if (is_null($this->_container)) {
            $def = [
                "db_{$this->configName}" => Definition::factory(
                        function() {
                            $args = Configuration::get($this->_configFile)
                                ->get($this->_configName);
                            $adapter = new Adapter($args);
                            return $adapter->initialize();
                        }
                    ),
                'sharedEventManager' => Definition::object(
                        'Zend\EventManager\SharedEventManager'
                    )
            ];
            $this->setContainer(ContainerBuilder::buildContainer($def));
        }
        return $this->_container;
    }
497672
public function getEventManager()
    {
        if (!$this->eventManager instanceof EventManagerInterface) {
            $this->setEventManager(new EventManager(array(__CLASS__, get_called_class())));
        }
        return $this->eventManager;
    }
654069
public static function getEventManager()
    {
        if (!isset(self::$event_manager[get_called_class()])) {
            self::$event_manager[get_called_class()] =
                EventDispatcher::getShareable(static::$static_scope);
        }
        return self::$event_manager[get_called_class()];
    }
458349
function event()
    {
        if (! $this->events ) {
            $events = new EventHeapOfSapi;
            $events->setMeeter( new MeeterIoc );

            $this->events = $events;
        }


        $this->events->collector()->setSapi($this); // also failure events need sapi
        return $this->events;
    }
754854
public static EventEngine getEventService() {
        CHFWBundle c = instance.get().get();
        if (null != c) {
            return c.eventService;
        }
        return null;
    }
116183
public function getEventManager(): EventManagerInterface
    {
        if (null === $this->events) {
            $this->setEventManager(new EventManager());
        }
        return $this->events;
    }
643865
protected function getEvents() {
        if (!$this->_events) {
            $this->_events = new EventList($this->version, $this->solution['sid']);
        }

        return $this->_events;
    }
534751
public function getEvents()
    {
        if (! $this->events) {
            $services = $this->getServices();
            $events   = $services->get('Events');
            $this->setEvents($events);
        }

        return $this->events;
    }
313904
public function getEventObject()
    {
        if ($this->currentOverriddenEvent) {
            return $this->currentOverriddenEvent;
        }

        $event = clone $this->masterEvent;

        // Ignoring the following block, because PHPUnit's code coverage
        // ignores most of these lines, and this messes with our stats.
        //
        // @codeCoverageIgnoreStart
        unset(
            $event->RRULE,
            $event->EXDATE,
            $event->RDATE,
            $event->EXRULE,
            $event->{'RECURRENCE-ID'}
        );
        // @codeCoverageIgnoreEnd

        $event->DTSTART->setDateTime($this->getDtStart(), $event->DTSTART->isFloating());
        if (isset($event->DTEND)) {
            $event->DTEND->setDateTime($this->getDtEnd(), $event->DTEND->isFloating());
        }
        $recurid = clone $event->DTSTART;
        $recurid->name = 'RECURRENCE-ID';
        $event->add($recurid);

        return $event;
    }
470661
public function getType()
    {
        $type = null;
        if (($parent = $this->getParent()) instanceof ElementHandler && $parent->hasAttribute(self::ATTRIBUTE_TYPE)) {
            $type = $parent->getAttribute(self::ATTRIBUTE_TYPE)->getValue(false, false);
        }
        return $type;
    }
1211235
public function getEventManager()
    {
        if (null === $this->events) {
            $this->setEventManager($this->getServiceLocator()->get('EventManager'));
        }

        return $this->events;
    }
690749
public function getEventManager() {
		if (empty($this->_eventManager)) {
			$this->_eventManager = new CommonEventManager();
			$this->_eventManager->loadListeners($this->_eventManager, 'Controller');
			$this->_eventManager->loadListeners($this->_eventManager, $this->name);
			$this->_eventManager->attach($this->Components);
			$this->_eventManager->attach($this);
		}
		return $this->_eventManager;
	}
1016028
protected function getConfigHandler()
    {
        if (null !== $typeInfo = ServiceManager::getServiceType($this->type)) {
            // lookup related service type config model
            return $typeInfo->getConfigHandler();
        }

        return null;
    }
408625
public function getEventTypes()
    {
        $this->request->allowMethod(['post', 'patch', 'put']);
        $calendarsTable = TableRegistry::Get('Qobo/Calendar.Calendars');

        $eventTypes = [];
        $data = $this->request->getData();

        $calendar = $calendarsTable->get($data['calendar_id']);
        $types = $this->CalendarEvents->getEventTypes(['calendar' => $calendar, 'user' => $this->Auth->user()]);

        foreach ($types as $item) {
            if (isset($item['name'])) {
                $eventTypes[] = $item;
            } else {
                $eventTypes[] = ['name' => $item, 'value' => $item];
            }
        }

        if (!empty($data['exclude'])) {
            foreach ($data['exclude'] as $type) {
                foreach ($eventTypes as $k => $item) {
                    if (preg_match("/^$type/i", $item['value'])) {
                        unset($eventTypes[$k]);
                    }
                }
            }

            $eventTypes = array_values($eventTypes);
        }

        $this->set(compact('eventTypes'));
        $this->set('_serialize', 'eventTypes');
    }
1003267
public String getEvent_type() {
    if (Event_Type.featOkTst && ((Event_Type)jcasType).casFeat_event_type == null)
      jcasType.jcas.throwFeatMissing("event_type", "ch.epfl.bbp.uima.genia.Event");
    return jcasType.ll_cas.ll_getStringValue(addr, ((Event_Type)jcasType).casFeatCode_event_type);}
818063
public function getConfig($key = null) {
		$results = $this->_getConfig($key);
		if (empty($results)) {
			return $results;
		}

		$event = new CakeEvent('Model.afterFind', $this, [$results, true, $key]);
		$event->modParams = 0;
		$this->getEventManager()->dispatch($event);

		return $event->result;
	}