getMissionGameConditionMapper : retrieve missionGameCondition mapper instance

@return Mapper/missionGameCondition $missionGameConditionMapper
977169
public function getMissionGameConditionMapper()
    {
        if (null === $this->missionGameConditionMapper) {
            $this->missionGameConditionMapper = $this->serviceLocator->get(
                'playgroundgame_mission_game_condition_mapper'
            );
        }

        return $this->missionGameConditionMapper;
    }
431953
public function getCommandHandlerMapping()
    {
        /** @var MigrationRunnerInterface $migrationRunner */
        $migrationRunner = $this->getRunner();
        $factory = new CollectionRunnerFactory($this->publisher, $migrationRunner);
        return [
            CollectionCommand::class => new CollectionHandler($factory),
            ConvergeCommand::class => new ConvergeHandler(),
            SingleCommand::class => new SingleHandler($migrationRunner),
        ];
    }
409082
public function getClassMap()
    {
        $communityEditionSourcePath = $this->facts->getCommunityEditionSourcePath();
        $backwardsCompatibilityClassMapFile = $communityEditionSourcePath . DIRECTORY_SEPARATOR .
                                              'Core' . DIRECTORY_SEPARATOR .
                                              'Autoload' . DIRECTORY_SEPARATOR .
                                              'BackwardsCompatibilityClassMap.php';

        if (!is_readable($backwardsCompatibilityClassMapFile)) {
            throw new \OxidEsales\UnifiedNameSpaceGenerator\Exceptions\InvalidBackwardsCompatibilityClassMapException(
                'Backwards compatibility class map file ' . $backwardsCompatibilityClassMapFile .
                ' is not readable or does not exist',
                static::ERROR_CODE_MISSING_BACKWARDS_COMPATIBILITY_CLASS_MAP
            );
        }

        $backwardsCompatibilityClassMap =
            include $backwardsCompatibilityClassMapFile;

        if (!is_array($backwardsCompatibilityClassMap)) {
            throw new \OxidEsales\UnifiedNameSpaceGenerator\Exceptions\InvalidBackwardsCompatibilityClassMapException(
                'Backwards compatibility class map is not an array ',
                static::ERROR_CODE_INVALID_BACKWARDS_COMPATIBILITY_CLASS_MAP
            );
        }

        return array_flip($backwardsCompatibilityClassMap);
    }
1308055
public static function getAccessControlManager()
	{
		if(self::$_instance === NULL)
			throw new SonicRuntimeException('Sonic instance not initialized');
		
		if(self::$_instance->accessControlManager != NULL)
			return self::$_instance->accessControlManager;
		else
			throw new AccessControlManagerException('AccessControlManager instance not found');
	}
721639
public static function map()
    {
        $permissions = [];

        foreach (static::get() as $permission) {
            $permissions[$permission->permission][] = (string) $permission->group_id;
        }

        return $permissions;
    }
1029009
private function getConfigPermissionOperations($class = null, $field = null)
    {
        $map = $this->getMapConfigPermissions();
        $class = PermissionUtils::getMapAction($class);
        $field = PermissionUtils::getMapAction($field);
        $operations = [];

        if (isset($map[$class][$field])) {
            $operations = array_keys($map[$class][$field]);
        }

        return $operations;
    }
833545
public function getClassMap()
    {
        $unifiedNamespaceClassMapOfCommunityEdition = parent::getClassMap();

        $professionalEditionRootPath = $this->facts->getProfessionalEditionRootPath();
        $unifiedNamespaceClassMapOfProfessionalEdition = $this->resolveUnifiedNamespaceClassMap($professionalEditionRootPath);

        return array_merge($unifiedNamespaceClassMapOfCommunityEdition, $unifiedNamespaceClassMapOfProfessionalEdition);
    }
182017
protected function getFreshAllPermissions()
    {
        $permissionsRoles = $this->getRolesPermissions(true);

        $permissions = app('defender.permission')->getActivesByUser($this);

        $permissions = $permissions->merge($permissionsRoles)
            ->map(function ($permission) {
                unset($permission->pivot, $permission->created_at, $permission->updated_at);

                return $permission;
            });

        return $permissions->toBase();
    }
954512
protected function getFreshRolesPermissions()
    {
        $roles = $this->roles()->get(['id'])->pluck('id')->toArray();

        return app('defender.permission')->getByRoles($roles);
    }
627395
public function getPermissionMap(ResourceType $type)
    {
        /** @var MaskDecoder[] $decoders */
        $decoders = $this->maskRepo->findBy(['resourceType' => $type]);
        $permsMap = [];

        foreach ($decoders as $decoder) {
            $permsMap[$decoder->getValue()] = $decoder->getName();
        }

        return $permsMap;
    }
485494
public function UserModel_GetCategoryViewPermission_Create($Sender) {
      static $PermissionModel = NULL;


      $UserID = ArrayValue(0, $Sender->EventArguments, '');
		$CategoryID = ArrayValue(1, $Sender->EventArguments, '');
      $Permission = GetValue(2, $Sender->EventArguments, 'Vanilla.Discussions.View');
		if ($UserID && $CategoryID) {
         if ($PermissionModel === NULL)
            $PermissionModel = new PermissionModel();
         
         $Category = CategoryModel::Categories($CategoryID);
         if ($Category)
            $PermissionCategoryID = $Category['PermissionCategoryID'];
         else
            $PermissionCategoryID = -1;
         
         $Result = $PermissionModel->GetUserPermissions($UserID, $Permission, 'Category', 'PermissionCategoryID', 'CategoryID', $PermissionCategoryID);
         return (GetValue($Permission, GetValue(0, $Result), FALSE)) ? TRUE : FALSE;
      }
      return FALSE;
   }
1236358
public function getPrizeCategoryUserMapper()
    {
        if (null === $this->prizeCategoryUserMapper) {
            $this->prizeCategoryUserMapper = $this->serviceLocator->get('playgroundgame_prizecategoryuser_mapper');
        }

        return $this->prizeCategoryUserMapper;
    }
1172204
public function getSettingsMapper()
    {
        if (null === $this->settingsMapper) {
            $this->settingsMapper = $this->getServiceManager()->get('playgrounddesign_settings_mapper');
        }

        return $this->settingsMapper;
    }
166428
public function getMode($throwException = false, $forceMode = false)
    {
        if (false === $this->enabled && true !== $forceMode) {
            return new NullMode();
        }

        switch ($this->type) {
            case 'nginx':
            case 'sendfile':
            case 'xaccel':
            case 'xaccelredirect':
            case 'x-accel':
            case 'x-accel-redirect':
                if (2 >= count($this->mapping)) {
                    $this->logger->error('Invalid xsendfile mapping configuration.');
                    if ($throwException) {
                        throw new RuntimeException('Mapping is not set up.');
                    }
                }

                return new NginxMode($this->mapping);
            case 'apache':
            case 'apache2':
            case 'xsendfile':
                return new ApacheMode($this->mapping);
            default:
                $this->logger->error('Invalid xsendfile type configuration.');
                if ($throwException) {
                    throw new InvalidArgumentException(sprintf(
                        'Invalid xsendfile type value "%s"',
                        $this->type
                    ));
                }

                return new NullMode();
        }
    }
1027289
public function getOverrideMap()
    {
        gplcart_static_clear();

        $map = array();

        foreach ($this->module->getEnabled() as $module) {

            $directory = GC_DIR_MODULE . "/{$module['id']}/override/classes";

            if (!is_readable($directory)) {
                continue;
            }

            foreach ($this->scanOverrideFiles($directory) as $file) {
                $original = str_replace('/', '\\', str_replace($directory . '/', '', preg_replace('/Override$/', '', $file)));
                $override = str_replace('/', '\\', str_replace(GC_DIR_SYSTEM . '/', '', $file));
                $map["gplcart\\$original"][$module['id']] = "gplcart\\$override";
            }
        }

        return $map;
    }
335955
public function getGameMapper()
    {
        if (null === $this->gameMapper) {
            $this->gameMapper = $this->serviceLocator->get('playgroundgame_game_mapper');
        }

        return $this->gameMapper;
    }
1325028
public function fulfillConditions($entry = null)
    {
        foreach ($this->getConditions() as $condition) {
            if ($condition->getAttribute() == MissionGameCondition::NONE) {
                continue;
            }
    
            // On passe au suivant si on a gagné
            if ($condition->getAttribute() == MissionGameCondition::VICTORY) {
                if (!$entry || !$entry->getWinner()) {
                    return false;
                }
            }
    
            // On passe au suivant si on a perdu
            if ($condition->getAttribute() == MissionGameCondition::DEFEAT) {
                if (!$entry || $entry->getWinner()) {
                    return false;
                }
            }
    
            // On passe au suivant si on a plus de n points
            if ($condition->getAttribute() == MissionGameCondition::GREATER) {
                if (!$entry || !($entry->getPoints() >= $condition->getValue())) {
                    return false;
                }
            }
    
            // On passe au suivant si on a moins de n points
            if ($condition->getAttribute() == MissionGameCondition::LESS) {
                if (!$entry || !($entry->getPoints() < $condition->getValue())) {
                    return false;
                }
            }
        }

        return true;
    }