/**
* Return the object Loader
* @return Loader
*/
static function get_instance()
{
if (!self::$instance) {
self::$instance = new self();
}
return self::$instance;
}
function __construct(Local &$local = null)
{
if ($local) {
$this->_local = $local;
}
self::$instance = $this;
}
public static function getInstance()
{
if (empty(self::$instance)) {
self::$instance = new self();
}
return self::$instance;
}
public static function getLoader()
{
if (empty(self::$instance)) {
self::$instance = new Loader();
}
return self::$instance;
}
/**
* Возвращает лоадер-синглтон
* @return Loader экземпляр лоадера
*/
public static function getInstance()
{
if (!isset(self::$instance)) {
self::$instance = new Loader();
}
return self::$instance;
}
/**
* Getting Instance
* @return object
*/
public static function getInstance()
{
if (self::$instance === null) {
self::$instance = new self();
}
return self::$instance;
}
public static function getInstance()
{
if (!isset(self::$instance)) {
$c = __CLASS__;
self::$instance = new $c();
}
return self::$instance;
}
public static function getInstance()
{
/**
* Статическая функция, которая возвращает экземпляр класса или создает новый при необходимости
* @return Loader
*/
// проверяем актуальность экземпляра
if (empty(self::$instance)) {
// создаем новый экземпляр
self::$instance = new self();
}
// возвращаем созданный или существующий экземпляр
return self::$instance;
}
public function module($moduleName)
{
$modulePath = Path::instance()->evaluate('lib.module');
if (file_exists($modulePath . "/{$moduleName}") && is_dir($modulePath . "/{$moduleName}")) {
if (file_exists($modulePath . "/{$moduleName}/{$moduleName}.xml")) {
if (is_readable($modulePath . "/{$moduleName}/{$moduleName}.xml")) {
foreach (ModuleConf::instance()->dependencies() as $dep) {
Loader::instance()->module($dep);
}
foreach (ModuleConf::instance()->includes() as $inc) {
Loader::instance()->inc($modulePath . "/{$moduleName}/" . trim($inc, '/'));
}
} else {
return -2;
}
} else {
return -1;
}
}
return 0;
}
/**
* Adiciona ao sitemap as páginas que são geradas pelos models, como páginas
* com os textos das notícias, etc
*
* @version
* 0.1 19/05/2010
* Inicial
* 0.2. 02/11/2010
* - Busca por um coluna "modified" no Model informado, depois por uma
* "created", se não encontrar nenhuma das duas, coloca a data atual
* - Modificado o padrão de passagem de variáveis para :var ao invés
* de {var}.
* - Eliminado o uso de extract(), e iniciado o uso de String::insert(),
* nativa do framework
* - Adicionado suporte ao encadeamento de métodos
* - Renomeado para addModel()
*
* @param string $model Nome do model a ser procurado
* @param array $params Parâmetros a serem repassados para o método all()
* do model
* @param array $configs Configurações individuais para cada model, nesse
* formato:
* array(
* 'loc' => '/noticia/:id/:slug}',
* 'lastmod' => ':modified',
* 'changefreq' => 'daily'
* 'priority' => '1'
* )
* Os textos no padrão ":nome" são os nomes das colunas do model
* informado, e serão substituídos pelos seus valores individuais
* quando o texto for gerado
* @return void
*/
public function addModel($model, $params = array(), $configs = array())
{
$results = Loader::instance('Model', $model)->all($params);
$this->results[$model] = $results;
$this->fields[$model] = array_keys(reset($results));
//se lastmod nao for informado, verificar se modified existe nos campos, e
//se nem existir nem for informado, adicionar a data atual
if (!isset($configs['lastmod'])) {
if (in_array('modified', $this->fields[$model])) {
$configs['lastmod'] = ':modified';
} elseif (in_array('created', $this->fields[$model])) {
$configs['lastmod'] = ':created';
} else {
$configs['lastmod'] = date('r');
}
}
$configs = array_merge(array('changefreq' => 'daily', 'priority' => 0.5), $configs);
//pr($this->fields);
foreach ($results as $row => $result) {
$output = array('loc' => Mapper::url(String::insert($configs['loc'], $result), true), 'lastmod' => date('c', strtotime(String::insert($configs['lastmod'], $result))), 'priority' => $configs['priority'], 'changefreq' => $configs['changefreq']);
$this->output[] = array_merge($configs, $output);
}
return $this;
}
/**
* Inicia a configuração das colunas a partir de uma consulta a
* um model
*
* @param array $model O model em que será feita a busca
* @param array $conditions Os parâmetros de configuração para a
* busca no model
* @return object
*/
public function startFromModel($model, $params = array())
{
//Inicia os parâmetros da url
$this->urlParams();
//$model = ClassRegistry::load($model, 'Model'); //v 0.1
$model = Loader::instance('Model', $model);
//v 0.2
$order = isset($this->urlParams['named']['order']) ? $this->urlParams['named']['order'] : $model->primaryKey;
$order .= isset($this->urlParams['named']['by']) ? ' ' . $this->urlParams['named']['by'] : ' ASC';
$model->order = $order;
$this->start($model->all($params));
return $this;
}
/**
* Cria o menu baseado no model
*
* @param string $model Nome do model
* @param array $params Parâmetros para a busca no banco de dados
* @param array $attrs Atributos para o menu gerado. Chaves permitidas:
* "class" define a class css do menu gerado
* "parentId" define a partir de qual parentId o menu será gerado
* @return Menu formado
*/
public function create($model, array $params = array(), array $attrs = array())
{
$this->modelObj = Loader::instance('Model', $model);
if (!array_key_exists('parentId', $attrs)) {
$parentId = 0;
}
$this->attrs = $attrs;
return $this->generate($parentId, $params);
}
public static function getInstance()
{
if (!isset(self::$instance)) {
if (is_readable('vendor/autoload.php')) {
self::$instance = (require 'vendor/autoload.php');
} else {
self::$instance = new Loader();
$conf = json_decode(file_get_contents('composer.json'), true);
$psr4 = $conf['autoload']['psr-4'];
foreach ($psr4 as $key => &$value) {
self::$instance->setPsr4($key, $value);
}
self::$instance->register(true);
}
}
return self::$instance;
}
/**
* function parse()
* Gera um rss a partir de uma busca
* @version
* 0.1 03/06/2009 Método inicial
* 1.0 16/05/2010 Método refatorado completamente, renomeado, trocados
* seus parâmetros, etc.
*
* @param $model O model a ser feita a busca
* @param $params Os parâmetros para a busca, será passado diretamente
* para o Model::all()
*/
public function parse($model, $params = array())
{
//fazendo a busca
$this->results = Loader::instance('Model', $model)->all($params);
//pegando somente os campos
$this->fields = !empty($this->results) ? array_keys(reset($this->results)) : array();
//Limpando os campos "relations" que não existem em $this->allowedItems
foreach ($this->config['relations'] as $key => $value) {
if (!in_array($key, $this->allowedItems)) {
unset($this->config['relations'][$key]);
}
}
//Criando o cabeçalho
$rss = new SimpleXmlElement('<?xml version="1.0" encoding="UTF-8" ?><rss xmlns:atom="http://www.w3.org/2005/Atom"></rss>');
$rss->addAttribute('version', '2.0');
$channel = $rss->addChild('channel');
//verificando pelas tags permitidas, evitará a
//inclusão de tags inválidas e poupará vários IFs.
foreach ($this->allowedHeaders as $header) {
if (!empty($this->config['headers'][$header])) {
$channel->addChild($header, $this->format($this->config['headers'][$header], $header));
}
}
//Procuro nos resultados
foreach ($this->results as $row => $result) {
$item = $channel->addChild("item");
foreach ($this->config['relations'] as $key => $field) {
$item->addChild($key, $this->format(String::insert($field, $result), $key));
// $item->addChild($key, $this->format($this->extract($field, $row), $key));
}
}
return $rss->asXml();
}
/**
* Inicia o helper a partir de um model
*
* @version 0.1 11/06/2011 Initial
*/
public function init($modelName, $subMenuName)
{
#Resetando todas as configurações antes de inicar
$this->reset();
$this->modelObject = Loader::instance('Model', $modelName);
$this->subMenuName = $subMenuName;
return $this;
}
/**
* Instance control
*
* @return Loader
*/
public static function getInstance()
{
return self::$instance === null ? self::$instance = new self() : ($ref =& self::$instance);
}
public function startFromSql($query)
{
$this->results = Loader::instance('Model', 'AppModel')->fetch($query);
return $this;
}
* }
* @return \JsonLoader\Object
*/
function load($filepath, $class_factory, $args = array())
{
$args = Util::parse_args($args, array('logger' => false, 'parent' => false));
$this->logger = $args['logger'] ? $args['logger'] : new Logger();
$this->filepath = $filepath;
if (empty($filepath)) {
Util::log_error("The filename passed was empty.");
}
if (!is_file($filepath)) {
Util::log_error("The file {$filepath} does not exist.");
}
$json = file_get_contents($filepath);
if (empty($json)) {
Util::log_error("The JSON value provided is empty.");
}
$data = @json_decode($json);
if (is_null($data)) {
Util::log_error("The JSON file {$filepath} has invalid syntax.");
}
if (!is_callable($class_factory)) {
Util::log_error("Class factory is not a callable.");
}
$object = call_user_func($class_factory, $data, $filepath, $args);
return $object;
}
}
Loader::$instance = new Loader();
$www_dir = 'www';
// Make sure your $*_dir settings check out
if (is_dir(DOC_ROOT.DS.$sys_dir)) { define('SYS_ROOT', realpath(DOC_ROOT.DS.$sys_dir)); }
if (is_dir(DOC_ROOT.DS.$mod_dir)) { define('MOD_ROOT', realpath(DOC_ROOT.DS.$mod_dir)); }
if (is_dir(DOC_ROOT.DS.$app_dir)) { define('APP_ROOT', realpath(DOC_ROOT.DS.$app_dir)); }
if (is_dir(DOC_ROOT.DS.$www_dir)) { define('WWW_ROOT', realpath(DOC_ROOT.DS.$www_dir)); }
// Don't need them anymore, don't want them polluting the application
unset($sys_dir, $mod_dir, $app_dir, $www_dir);
// If we can't find one of the directories, there's a "problem"
if (!defined('DOC_ROOT') || !defined('SYS_ROOT') || !defined('MOD_ROOT') || !defined('APP_ROOT') || !defined('WWW_ROOT')) {
die('Error: Please check your $*_dir settings.');
}
// Get the base Elastic class
require SYS_ROOT.DS.'classes'.DS.'elastic'.PHP_EXT;
// Include the Loader class
require SYS_ROOT.DS.'classes'.DS.'loader'.PHP_EXT;
// Include the Container class
require SYS_ROOT.DS.'classes'.DS.'container'.PHP_EXT;
// Create the default loader. Can be accessed later by using Loader::instance('default') again.
Loader::instance('default')->register();
// Include the initialisation file for the core
require SYS_ROOT.DS.'init'.PHP_EXT;
require APP_ROOT.DS.'bootstrap'.PHP_EXT;
?>
public function model($model)
{
$this->model = Loader::instance('Model', $model);
return $this;
}
/**
* Inicia o uso do helper, fazendo a consulta que vai gerar os dados
*
* @version 0.1 31/10/2010
* - Initial
* 0.2 07/11/2010
* - Suporte às versões do model antes da existência de Model::schema()
*
* @example
* //Gera o formulário baseado no model 'Users'
* <code>echo $this->start('Users')</code>
* //Gera o formulário baseado em Users, e preenche com os dados do user id=1
* <code>echo $this->start('Users', array('id' => '1'))</code>
*
* @param string $model Nome do model
* @param array $conditions As condições de busca, caso necessite de buscar. Esse
* array será repassado para o método Model::first(), diretamente à chave
* 'conditions'.
* @return object $this
*/
public function start($model, $conditions = array())
{
$modelObj = Loader::instance('Model', $model);
if (empty($modelObj->schema)) {
$this->schema = $modelObj->schema();
} else {
$this->schema = $modelObj->schema;
}
//@to do
//Verificar se há alguma configuração de campos no model, e importá-la
//para gerar o form
$this->form();
if (!empty($conditions)) {
$this->autoValues($modelObj->first(array('conditions' => $conditions)));
}
$this->configure();
return $this;
}
