public function __construct()
{
$this->extensions = new Map();
$this->packages = new Map();
// load up all extensions
$exts = ExtensionQuery::create()->joinPackage()->find();
foreach ($exts as $ext) {
/* @var $ext Extension */
$key = $ext->getKey();
$packageName = $ext->getPackage()->getName();
$data = Json::decode($ext->getData());
// add to global extensions
if (!$this->extensions->has($key)) {
$this->extensions->set($key, new ArrayList());
}
$this->extensions->get($key)->add($data);
// add to package extensions
if (!$this->packages->has($packageName)) {
$this->packages->set($packageName, new Map());
}
$pkg = $this->packages->get($packageName);
if (!$pkg->has($key)) {
$pkg->set($key, new ArrayList());
}
$pkg->get($key)->add($data);
}
}
/**
* Returns a set of allowed action ids
*
* @param User $user
* @return Set
*/
private function getPermissionTable(User $user)
{
$userId = $user->getId();
if ($this->permissionTable->has($userId)) {
return $this->permissionTable->get($userId);
}
// always allow what guests can do
$guestGroup = GroupQuery::create()->findOneByIsGuest(true);
// collect groups from user
$groups = GroupQuery::create()->filterByUser($user)->find();
$userGroup = GroupQuery::create()->filterByOwnerId($userId)->findOne();
if ($userGroup) {
$groups[] = $userGroup;
}
$groups[] = $guestGroup;
// ... structure them
$permissionTable = new Set();
foreach ($groups as $group) {
foreach ($group->getActions() as $action) {
$permissionTable->add($action->getId());
}
}
$this->permissionTable->set($userId, $permissionTable);
return $this->permissionTable->get($userId);
}
/**
* @param Skill $skill
* @return Skill[]
*/
private function getDescendents(Skill $skill)
{
if (!$this->descendents->has($skill->getId())) {
$this->descendents->set($skill->getId(), $skill->getDescendents());
}
return $this->descendents->get($skill->getId());
}
/**
*
* @param string $packageName
* @return CompletePackage
*/
public function getComposerPackage($packageName)
{
if ($this->composerCache->has($packageName)) {
return $this->composerCache->get($packageName);
}
$package = $this->loader->load($this->getJson($this->getFile($packageName)));
$this->composerCache->set($packageName, $package);
return $package;
}
/**
* Adds a constant
*
* @param string|PhpConstant $nameOrConstant constant name or instance
* @param string $value
* @return $this
*/
public function setConstant($nameOrConstant, $value = null, $isExpression = false)
{
if ($nameOrConstant instanceof PhpConstant) {
$name = $nameOrConstant->getName();
$constant = $nameOrConstant;
} else {
$name = $nameOrConstant;
$constant = new PhpConstant($nameOrConstant, $value, $isExpression);
}
$this->constants->set($name, $constant);
return $this;
}
/**
* @param array $contents
*/
protected function parse($contents = [])
{
$data = new Map($contents);
$this->title = $data->get('title', '');
$this->class = $data->get('class', '');
$this->extensionPoints = $data->get('extension-points', new Map());
$this->extensions = new Map();
$extensions = CollectionUtils::toMap($data->get('extensions', []));
foreach ($extensions as $key => $val) {
$this->extensions->set($key, $val->map(function ($v) {
return $v->toArray();
}));
}
return $data;
}
/**
*
*/
public function import($data, Event $event)
{
$csv = Reader::createFromString(trim($data));
$csv->setDelimiter(';');
// get startgroups at first
$groups = new Map();
foreach ($csv->fetchColumn(0) as $name) {
if (!$groups->has($name)) {
$startgroup = $this->getStartgroup($name);
$startgroup->setEvent($event);
$groups->set($name, $startgroup);
}
}
$id = 0;
foreach ($csv as $row) {
$id++;
$routine = $this->getRoutine($id);
$group = $groups->get($row[0]);
$judges = (count($row) - 1) / 3;
for ($j = 1; $j <= $judges; $j++) {
$score = new PerformanceScore();
$score->setRoutine($routine);
$score->setJudge($group->getPerformanceJudge($j));
$score->setExecution($row[($j - 1) * 3 + 1]);
$score->setChoreography($row[($j - 1) * 3 + 2]);
$score->setMusicAndTiming($row[($j - 1) * 3 + 3]);
$score->setTotal($row[($j - 1) * 3 + 1] + $row[($j - 1) * 3 + 2] + $row[($j - 1) * 3 + 3]);
$routine->addPerformanceScore($score);
}
$group->addRoutine($routine);
$group->save();
}
$event->save();
}
/**
* Loads a module and returns the associated class or returns if already loaded
*
* @param String $packageName
* @throws ModuleException
* @return AbstractModule
*/
public function load($packageName)
{
if ($this->loadedModules->has($packageName)) {
return $this->loadedModules->get($packageName);
}
// check existence
if (!$this->installedModules->has($packageName)) {
throw new ModuleException(sprintf('Module (%s) does not exist.', $packageName), 500);
}
// check activation
if (!$this->activatedModules->has($packageName)) {
throw new ModuleException(sprintf('Module (%s) not activated', $packageName), 501);
}
$model = $this->activatedModules->get($packageName);
if ($model->getInstalledVersion() > $model->getActivatedVersion()) {
throw new ModuleException(sprintf('Module Version Mismatch (%s). Module needs to be updated by the Administrator', $packageName), 500);
}
// load
$className = $model->getClassName();
/* @var $module AbstractModule */
$module = new $className($model, $this->service);
$this->loadedModules->set($packageName, $module);
// load locale
$localeService = $this->getServiceContainer()->getLocaleService();
$file = sprintf('/%s/locales/{locale}/translations.json', $packageName);
$localeService->loadLocaleFile($file, $module->getCanonicalName());
return $module;
}
/**
* Recursively transforms data into a map (on the first level, deeper levels
* transformed to an appropriate collection) (experimental API)
*
* @param array|Iterator $collection
* @return Map
*/
public static function toMap($collection)
{
$map = new Map();
foreach ($collection as $k => $v) {
$map->set($k, self::toCollection($v));
}
return $map;
}
public function testAddGetRemove()
{
$key1 = 'key1';
$key2 = 'key2';
$key3 = 'key3';
$item1 = 'item 1';
$item2 = 'item 2';
$item3 = 'item 3';
$items = [$key1 => $item1, $key2 => $item2];
$keys = new Set([$key1, $key2]);
$values = new ArrayList([$item1, $item2]);
$map = new Map();
$map->set($key1, $item1);
$this->assertEquals(1, $map->size());
$this->assertEquals($item1, $map->get($key1));
$this->assertTrue($map->has($key1));
$this->assertFalse($map->has($key2));
$map->remove($key1);
$this->assertEquals(0, $map->size());
$map->setAll($items);
$this->assertEquals(2, $map->size());
$this->assertEquals($keys, $map->keys());
$this->assertEquals($values, $map->values());
$map->set($key3, $item3);
$this->assertEquals(3, $map->size());
$map->clear();
$this->assertEquals(0, $map->size());
$dupKeyItems = [$key1 => $item1, $key2 => $item2];
$map->setAll($dupKeyItems);
$map->set($key2, $item3);
$this->assertEquals(2, $map->size());
$this->assertEquals($item3, $map->get($key2));
$this->assertEmpty($map->get('non_existing_key'));
$this->assertEmpty($map->remove('non_existing_key'));
$this->assertEquals([], $map->get('non_existing_key', []));
}
private function registerListeners()
{
$reg = $this->service->getExtensionRegistry();
$listeners = $reg->getExtensions(CoreModule::EXT_LISTENER);
$map = new Map();
$getClass = function ($className) use($map) {
if (class_exists($className)) {
if ($map->has($className)) {
$class = $map->get($className);
} else {
$class = new $className();
$map->set($className, $class);
}
if ($class instanceof KeekoEventListenerInterface) {
$class->setServiceContainer($this->service);
}
return $class;
}
return null;
};
foreach ($listeners as $listener) {
// subscriber first
if (isset($listener['subscriber'])) {
$className = $listener['subscriber'];
$subscriber = $getClass($className);
if ($subscriber !== null && $subscriber instanceof KeekoEventSubscriberInterface) {
$this->dispatcher->addSubscriber($subscriber);
}
}
// class
if (isset($listener['class']) && isset($listener['method']) && isset($listener['event'])) {
$className = $listener['class'];
$class = $getClass($className);
if ($class !== null && $class instanceof KeekoEventListenerInterface && method_exists($class, $listener['method'])) {
$this->dispatcher->addListener($listener['event'], [$class, $listener['method']]);
}
}
}
}
public function setResponder($type, $class)
{
$this->responder->set($type, $class);
}
/**
* Adds a method
*
* @param PhpMethod $method
* @return $this
*/
public function setMethod(PhpMethod $method)
{
$method->setParent($this);
$this->methods->set($method->getName(), $method);
return $this;
}
/**
* Sets the scheme
*
* @param string $id
* @param Set $scopes
* @return $this
*/
public function add($id, Set $scopes)
{
$this->securities->set($id, $scopes);
return $this;
}
/**
* Adds a property
*
* @param PhpProperty $property
* @return $this
*/
public function setProperty(PhpProperty $property)
{
$property->setParent($this);
$this->properties->set($property->getName(), $property);
return $this;
}
private function prepareMap(Map $map)
{
foreach (array_keys($this->targets) as $target) {
$map->set($target, new ArrayList());
}
}
/**
* Sets the response
*
* @param Response $code
*/
public function add(Response $response)
{
$this->responses->set($response->getCode(), $response);
}
public function testTextAsKey()
{
$map = new Map();
$key = new Text('k');
$map->set($key, 'val');
$this->assertTrue($map->has($key));
$this->assertEquals('val', $map->get($key));
$map->remove($key);
$this->assertEquals(0, $map->size());
}
/**
* Sets the path
*
* @param Path $path
* @return $this
*/
public function add(Path $path)
{
$this->paths->set($path->getPath(), $path);
return $this;
}
/**
* Sets the scheme
*
* @param SecurityScheme $scheme
* @return $this
*/
public function add(SecurityScheme $scheme)
{
$this->schemes->set($scheme->getId(), $scheme);
return $this;
}
/**
* A list of tags sorted by tag-name
*
* @return ArrayList
*/
public function getSortedTags()
{
if ($this->comparator === null) {
$this->comparator = new TagNameComparator();
}
// 1) group by tag name
$group = new Map();
foreach ($this->tags as $tag) {
if (!$group->has($tag->getTagName())) {
$group->set($tag->getTagName(), new ArrayList());
}
$group->get($tag->getTagName())->add($tag);
}
// 2) Sort the group by tag name
$group->sortKeys(new TagNameComparator());
// 3) flatten the group
$sorted = new ArrayList();
foreach ($group->values() as $tags) {
$sorted->addAll($tags);
}
return $sorted;
}
/**
* Sets the header
*
* @param Header $header
*/
public function add(Header $header)
{
$this->headers->set($header->getHeader(), $header);
}
/**
* @return Skill[]
*/
public function getDescendents()
{
$descendents = new Map();
$add = function (Skill $skill) use($descendents) {
if ($skill->isMultiple() || $skill->isTransition()) {
return;
}
$descendents->set($skill->getId(), $skill);
$descendents->setAll($skill->getDescendents());
};
foreach ($this->getVariations() as $variation) {
$add($variation);
}
foreach ($this->getChildren() as $child) {
$add($child);
}
return $descendents->toArray();
}
/**
* Sets the field
*
* @param string name
* @param Schema $schame
*/
public function set($name, Schema $schema)
{
$this->definitions->set($name, $schema);
}
