Get an user attribute

@param   string  $identifier Attribute identifier, eg .foo.bar
@param   mixed   $default Default value when the attribute doesn't exist
@return  mixed   The value
770790
public function get($identifier, $default = null)
    {
        $attributes = $this->getData()->attributes;

        $result = $default;
        if(isset($attributes[$identifier])) {
            $result = $attributes[$identifier];
        }

        return $result;
    }
473696
public function findByIdentifier($identifier)
    {
        $object = $this->persistenceManager->getObjectByIdentifier($identifier, $this->entityClassName);
        if ($object === null) {
            foreach ($this->addedResources as $addedResource) {
                if ($this->persistenceManager->getIdentifierByObject($addedResource) === $identifier) {
                    $object = $addedResource;
                    break;
                }
            }
        }

        return $object;
    }
331783
public function get($identifier)
    {
        if ($this->themeLoaded === false) {
            $this->loadThemes();
        }

        return $this->themeList->get($identifier);
    }
468109
public static function logIn(string $provider, string $identifier): ?User
    {
        if ($provider = static::where(compact('provider', 'identifier'))->first()) {
            $provider->touch();

            return $provider->user;
        }

        return null;
    }
1361425
public function findUser($identifier)
    {
        $user = null;
        if($this->isLoaded($identifier))
        {
            if (!is_numeric($identifier)) {
                $user = $this->_emails[$identifier];
            } else {
                $user = parent::findUser($identifier);
            }
        }

        return $user;
    }
416655
public function retrieveByToken($identifier, $token)
	{
		if (Authorizer::validateAccessToken(false, $token)) {
			return $this->retrieveById(Authorizer::getResourceOwnerId());
		}

		return null;
	}
997142
public function identifier($identifier = null)
    {
        if (null === $identifier) {
            return $this->identifier;
        }

        $this->identifier = $identifier;
        return $this;
    }
1168228
public function getClass($identifier)
    {
        $result     = null;
        $identifier = (string) $identifier;

        if(isset($this->_classes[$identifier])) {
            $result = $this->_classes[$identifier];
        }

        return $result;
    }
266436
public function whoamiGet($ident, $default = null)
  {
    if(array_key_exists($ident, $this->whoami()))
    {
      return $this->whoami[$ident];
    }

    return $default;
  }
356924
public static function findDefaultClass($identifier)
    {
        $strIdentifier = (string) $identifier;

        if (isset(self::$_defaults[$strIdentifier])) {
            $classname = self::$_defaults[$strIdentifier];

            if ($classname === false || class_exists($classname)) {
                return $classname;
            }
        }

        $classbase = 'Lib'.ucfirst($identifier->package).AnInflector::implode($identifier->path);
        $loader = AnService::get('anahita:loader');
        $classname = $classbase.ucfirst($identifier->name);

        if (!class_exists($classname)) {
            $classname = $classbase.'Default';

            if (!class_exists($classname)) {
                $classname = false;
            }
        }

        if ($classname === false) {
            if (isset(self::$_identifiers[$strIdentifier])) {
                $config = self::$_identifiers[$strIdentifier];

                if (isset($config['default'])) {
                    $classes = array_unique($config['default']);
                } else {
                    $classes = get_prefix($config['prefix'], $config['name']);

                    if (isset($config['fallback'])) {
                        $classes[] = $config['fallback'];
                    }
                }
                foreach ($classes as $class) {
                    //make sure to find  path first
                    //then try to load it
                    if ($loader->findPath($class, $identifier->basepath) &&
                        $loader->loadClass($class, $identifier->basepath)
                           ) {
                        $classname = $class;
                        break;
                    }
                }
            }
        }

        self::setDefaultClass($strIdentifier, $classname);

        return $classname;
    }
331730
final public function getIdentifier($identifier = null)
	{
		if(isset($identifier)) {
		    $result = $this->__service_container->getIdentifier($identifier);
		} else {
		    $result = $this->__service_identifier; 
		}
	    
	    return $result;
	}
288982
public function getAttribute( string $name, $defaultValue = false )
   {

      if ( ! $this->hasAttribute( $name ) )
      {
         return $defaultValue;
      }

      return $this->_attributes[ $name ];

   }
456895
public function getAttribute($name, $default = null)
    {
        $value = $this->reader->getAttribute($name);

        return null !== $value ? $value : $default;
    }
317273
public function get($name, $default = null)
    {
        return isset($this->attributes[$name]) ? $this->attributes[$name] : $default;
    }
684935
public function getParameterType($identifier)
    {
        return isset($this->parameterTypes[$identifier]) ? $this->parameterTypes[$identifier] : null;
    }
1132796
public function getContentById($identifier, $default = "", $type = "")
    {
        $index = $this->getRegistryIndex($this->section);

        return $this->getESAdaptor()->getDocument($identifier, $index->getName(), $type);
    }
1237189
static function fetchPartByIdentifier( $identifier )
    {
        $parts = eZNavigationPart::fetchList();

        if ( isset( $parts[$identifier] ) )
            return $parts[$identifier];

        // Return the first part which is the default
        if ( isset( $parts[0] ) )
            return $parts[0];

        return false;
    }