Faz tempo que não passo por aqui, e põem tempo nisso.

Para que o blog não fique sem atualizações por minha falta de tempo para elaborar artigos maiores, irei inaugurar com esse post um série de mini posts, que vão servir para tirar algumas dúvidas ou ajudar em uma coisinha ou outra, ou seja, de acordo que eu aprenda algo novo posto por aqui e compartilho, sei que as vezes não vai ser novidade mais vai ajudar alguém isso garanto. ;D

Então vamos um dica simples e que precisei esses dias foi alterar o nome do computador no Ubuntu, abaixo segue o código.

Vá no terminal Shell e digite o seguinte comando:

 sudo vi /etc/hostname

O comando acima vai abrir o arquivo para edição, é bem provável que solicite a sua senha, então a digite.

Depois ao exibir o arquivo você verá o nome do computador ai basta apertar a tecla “i”(insert) e ir até a linha e editar o nome depois, aperte a tecla ESC e em seguida escreva

:wq!

Depois disso basta reiniciar o servidor, basta usar o comando abaixo

sudo reboot

Pronto!

Agora você conseguiu mudar o nome do servidor =D

1º – Abra o Messenger
Digite seu e-mail e sua senha, marque a caixa (Lembrar minhas ID e senha)
Desmarque a caixa (Entrar automaticamente)
Agora clique em (ENTRAR) para logar no Messenger

2º – Abra o Gerenciador de credenciais
Com o Messenger ainda aberto, clique em iniciar e na caixa de pesquisa busque pela palavra “credenciais”.
Abra o programa chamado, (Gerenciar credenciais do Windows)

3º – Excluindo a senha salva
Após abrir o (Gerenciador de credenciais do Windows)…
Procure pelo seu e-mail na lista “Credenciais Genéricas”
Clique sobre o seu e-mail e então serão exibidas informações adicionais sobre seu e-mail
Clique no botão “Editar”
Deve aparecer uma tela com seu e-mail e sua senha
Apenas apague sua senha e depois clique em “Salvar”

4º – Verificando
Agora, feche completamente o Messenger.
Pronto, abra e verifique que seu e-mail ficou salvo!

Você pode fazer o mesmo processo com vários e-mails diferentes.
Mas atenção, não mecha em outras configurações do (Gerenciador de credenciais do Windows) sob risco de danificar o funcionamento de outros programas.

Até a próxima!

Hoje iremos falar sobre como criar o controle de acesso para os usuários no sistema, ou seja as permissões que o usuário possui baseado em seu perfil dentro do sistema.

A ACL é composta de três funções básicas, são elas:

Perfil (Role)
Eu entendo como nível, como se fosse em um hierarquia, é de acordo com o perfil do usuário, que ele terá acesso as funcionalidades do sistema.
Ex.: Administrador, Técnico, e etc..

Funcionalidades (Resource)
São as funções que você disponíbiliza, ou seja, adicionar, editar, excluir, listar entre outros.

Permissões (Permissions)
Rs, esse acho que nem preciso falar, mas é a ligação entre o perfil e funcionalidade, é onde determino qual funcionalidade o perfil terá ou não acesso.

Então vamos começar o código! (Até que enfim! \0/)

No meu caso eu criei um plugin, mas acredito que possa ser adaptado a ACL e colocada dentro do Bootstrap.

Iremos  por parte, primeiramente vamos criar a classe e instânciar o Zend_Acl.

<?php
class Application_Plugin_ACL extends Zend_Controller_Plugin_Abstract
{
    private $acl;

    public function __construct()
    {
        // Instânciamos a ACL
        $this->acl = new Zend_Acl();
    }

    public function preDispatch(Zend_Controller_Request_Abstract $request)
    {
    }
}
?>

Agora vamos criar dois perfis para os usuários.

• admin = administrador do sistema
• operador = Usuário comum do sistema

na prática

<?php
class Application_Plugin_ACL extends Zend_Controller_Plugin_Abstract
{
    private $acl;

    public function __construct()
    {
        // Instânciamos a ACL
        $this->acl = new Zend_Acl();

        // Criando os perfis
        $this->acl->addRole(new Zend_Acl_Role('operador')) //Operador
                  ->addRole(new Zend_Acl_Role('admin')); // Administrador</pre>
}

 public function preDispatch(Zend_Controller_Request_Abstract $request)
 {
 }
}
?>

Agora que criamos os perfis, vamos determinar as funcionalidades do sistema.

<?php
class Application_Plugin_ACL extends Zend_Controller_Plugin_Abstract
{
    private $acl;

    public function __construct()
    {
        // Instânciamos a ACL
        $this->acl = new Zend_Acl();

        // Criando os perfis
        $this->acl->addRole(new Zend_Acl_Role('operador')) //Operador
                  ->addRole(new Zend_Acl_Role('admin')); // Administrador

        // Funcionalidades
        // Definicao modulo:controller, action
        $this->acl->add(new Zend_Acl_Resource('default:auth', 'logout')) // Para sair do sistema
                  ->add(new Zend_Acl_Resource('default:users')) // Cadastro de usuarios
                  ->add(new Zend_Acl_Resource('default:noticias')); // Cadastro de notícias</pre>
 }

 public function preDispatch(Zend_Controller_Request_Abstract $request)
 {

 }
}
?>

Agora já está quase pronto, vamos pra o próximo passo, definir as permissões dentro da ACL.

<?php
class Application_Plugin_ACL extends Zend_Controller_Plugin_Abstract
{
    private $acl;

    public function __construct()
    {
        // Instânciamos a ACL
        $this->acl = new Zend_Acl();

        // Criando os perfis
        $this->acl->addRole(new Zend_Acl_Role('operador')) //Operador
                  ->addRole(new Zend_Acl_Role('admin')); // Administrador

        // Funcionalidades
        // Definicao modulo:controller, action
        $this->acl->add(new Zend_Acl_Resource('default:auth', 'logout')) // Para sair do sistema
                  ->add(new Zend_Acl_Resource('default:users')) // Cadastro de usuarios
                  ->add(new Zend_Acl_Resource('default:noticias')); // Cadastro de notícias

        // Definir as permissões
        // perfil, modulo:controller, action
        // Metódo allow é de permissão
        // Metódo deny é de negação

        // Perfil: Operador
        $this->acl->allow('operador', 'default:auth', 'logout') // Tem que permitir que cara saia não é mesmo, ah não ser que o perfil seja prisioneiro ai não ehaueshuase =D
                  ->allow('operador', 'default:noticias', array('index', 'edit')) // Definer por ações, vamos dizer que o cara so possa listar e editar
                  ->deny('operador', 'default:noticias', 'delete') // e não permitir ele excluir a notícia
                  ->deny('default:users') //não vamos permitir que o operador administre os usuários

        // Perfil: Admin
        // E para o admin tudo =D
                  ->allow('admin', 'default:auth', 'logout')
                  ->allow('admin', 'default:noticias')
                  ->allow('admin', 'default:users');

}

 public function preDispatch(Zend_Controller_Request_Abstract $request)
 {

 }
}
?>

Agora que já foram definidos os perfis, funcionalidades e permissões, falta apenas fazer a verificação e pronto! =D

<?php
class Application_Plugin_ACL extends Zend_Controller_Plugin_Abstract
{
    private $acl;

    public function __construct()
    {
        // Instânciamos a ACL
        $this->acl = new Zend_Acl();

        // Criando os perfis
        $this->acl->addRole(new Zend_Acl_Role('operador')) //Operador
                  ->addRole(new Zend_Acl_Role('admin')); // Administrador

        // Funcionalidades
        // Definicao modulo:controller, action
        $this->acl->add(new Zend_Acl_Resource('default:auth', 'logout')) // Para sair do sistema
                  ->add(new Zend_Acl_Resource('default:users')) // Cadastro de usuarios
                  ->add(new Zend_Acl_Resource('default:noticias')); // Cadastro de notícias

        // Definir as permissões
        // perfil, modulo:controller, action
        // Metódo allow é de permissão
        // Metódo deny é de negação

        // Perfil: Operador
        $this->acl->allow('operador', 'default:auth', 'logout') // Tem que permitir que cara saia não é mesmo, ah não ser que o perfil seja prisioneiro ai não ehaueshuase =D
                  ->allow('operador', 'default:noticias', array('index', 'edit')) // Definer por ações, vamos dizer que o cara so possa listar e editar
                  ->deny('operador', 'default:noticias', 'delete') // e não permitir ele excluir a notícia
                  ->deny('default:users') //não vamos permitir que o operador administre os usuários

        // Perfil: Admin
        // E para o admin tudo =D
                  ->allow('admin', 'default:auth', 'logout')
                  ->allow('admin', 'default:noticias')
                  ->allow('admin', 'default:users');
  }

 public function preDispatch(Zend_Controller_Request_Abstract $request)
 {
 // Primeiro vamos instânciar o Zend_Auth
 $auth = Zend_Auth::getInstance();
 // Agora vamos descobri qual o modulo, controller e action que o usuário está acessando
 $module = $request->getModuleName();
 $controller = $request->getControllerName();
 $action = $request->getActionName();

 /* Agora que já capturamos a ação do usuário, vamos verificar se o usuário está logado, caso esteja vamos verificar se ele tem acesso a funcionalidade */
 if($auth->hasIdentity()) {
 // Beleza o cabra ta logado, agora vamos ver se ele tem permissão
 $identity = $auth->getIdentity();

 if(!$this->acl->isAllowed($identity->perfil, $module.':'.$controller, $action)) {
 /* Agora é so direcionar para outra página ou gerar o erro, eu faço o seguinte seto o controller de error e ação forbidden que é o erro 403, ficando assim.*/
 $request->setControllerName('error')->setActionName('forbidden');
 }
 }
 }
}
?>

É isso ai pessoal, espero que tenham gostado o próximos artigos serão sobre Zend_Navigation para criar menus e depois a integração do Zend_Navigation com o Zend_Acl para que o usuário visualize somente o menu que tem direito.

Então abraço a todos,

John Marques

Hoje vamos falar sobre Smarty, um sistema de templates para PHP, mais especificamente iremos falar sobre como gerar cache como Smarty.

Decide postar sobre esse assunto, pois estou trabalhando com um site que vem dando dor de cabeça para seu dono, pois o grande número de acessos ao site, faz com que o processamento e número de requisições ao banco seja bem alto, deixando o site mais lento.

Mas a ideia de usar o Cache nesse site é por que, por conta dessa performance o site já foi retirado do ar por vários hospedeiros, pois consome muito processamento do servidor de hospedagem, ai o dono do site, tem que ficar migrando de servidor em servidor até achar um que suporte de fato.

Então se não usa “WordPress com aquele plugin WP Super Cache”, e quer da um melhorada na performance do site, veja abaixo um resumo sobre como usar o cache do Smarty. =D

Vantagens de se usar o cache

• Diminuir o processamento
• Diminuir o número de requisições ao banco de dados

Desvantagens de se usar o cache

• Administração dos arquivos de cache

Instalando o Smarty

Faça primeiramente o download da versão estável da biblioteca do Smarty no seguinte link http://www.smarty.net/do_download.php?download_file=Smarty-2.6.26.zip,  depois extraia o o arquivo e zip e copie a pasta do Smarty para a pasta do seu site.

Crie as seguintes

Essa estrutura não é obrigatória! Você pode fazer como achar que melhor adequado, o importante é que se sete os caminhos corretamente, logo abaixo veremos como.

Agora vamos para  o código. \0/

Primeiro vamos criar o arquivo index.tpl na pasta tpl_files, será a template do arquivo inicial.

<html>
<head>
<title><strong>{$titulo}</strong></title>
</head>
<body topmargin="0" leftmargin="0" rigthmargin="0">
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td height="50">
<strong>{$nome}</strong>, seja bem vindo ao site <strong>{$site}</strong>
</td>
</tr>
</table>
</body>
</html>

Agora vamos para o arquivo index.php, que irá chamar o Smarty e fazer o trabalho com cache.

// Include a classe do Smarty
require_once('Smarty-2.6.26/libs/Smarty.class.php');

// Caminho da pasta do site
define('PATH_ROOT', dirname(__FILE__));

// Instância o objeto
$smarty = new Smarty();
// Configurando os caminhos das pasta para o smarty
$smarty->template_dir = PATH_ROOT . '/tpl_files';
$smarty->compile_dir = PATH_ROOT . '/tpl_compiler';
$smarty->cache_dir = PATH_ROOT . '/tpl_cache';
$smarty->config_dir = PATH_ROOT . '/tpl_configs';

// Define que o Smarty irá utilizar cache
// Opção 1 : Diz para o Smarty que ele deve utilizar o tempo de vida, definido na configuração do Smarty
// Opção 2 : Diz para o Smarty que ele deve utilizar o tempo de vida, definido no arquivo de cache
$smarty->caching = 2;

// O Smarty já define o tempo de vida do cache de uma hora,
// mas podemos alterar. Lembrando que o tempo é em segundos
$smarty->cache_lifetime = 86400; // 1 dia

// Agora vamos verificar se existe um arquivo de cache
// Caso não exista ele passa os dados para a template
if(!$smarty->is_caching('index.tpl')) {
   $smarty->assign(array(
      'titulo' => 'John Marques.com.br - Gerando cache com Smarty',
      'nome' => 'Fulano',
      'site' => 'www.johnmarques.com.br'
   ));
}

// Exibe a template
$smarty->display('index.tpl');

Seguinte no arquivo index.php, o cache só é excluído e gerado um novo quando o arquivo de cache expira, caso contrário ele exibe o arquivo de cache.

Agora para você excluir um arquivo de cache é simples, abaixo está o código =D

// Exclui o arquivo de cache da template index.tpl
$smarty->clear_cache('index.tpl');
// Exclui todos os arquivos de cache
$smarty->clear_all_cache();

Agora vamos dizer que precise de vários arquivos de cache para uma mesma template, ai você vai dizer pra que John, ai eu digo, imagine um sistema de notícias, podemos criar um cache para cada noticia. =D

Como?

Agora mostro como ! =D

// ID da notícia
$noticia_id = $_GET['id'];

//No momento em que se verifica se existe o arquivo de cache passe o segundo parâmentro do método, que é a identifição do chace ou $cache_id.
// O mesmo deve se fazer no display
if(!$smarty->is_caching('noticia.tpl', $noticia_id)) {
   // busca os dados na notítica
}

// Exibe a template
$smarty->display('noticia.tpl', $noticia_id);

// Para excluir basta informa o cache_id
$smarty->clear_cache('noticia.tpl', $noticia_id);
// ou limpar todos
$smarty->clear_all_cache();

Perceba que ele irá criar um arquivo de cache para cada notícia que você visualizar.

É isso ai, espero que tenham gostado do arquivo, e que isso possa ajudar a otimizar a performance dos sites que você produzirem.

Para saber mais sobre a documentação do Smarty acesse http://www.smarty.net/manual/pt_BR/.

Então até a próxima.

Abraços,

John Marques

Estou a um tempo me dedicando ao Zend Framework, por que acredito ser um boa escolha na questão de tempo e nível de desenvolvimento e até o momento não me arrependo da escolha de aprender, tenho volta e meia dificuldade, mas acontece não é mesmo, da mesma forma quando aprendemos a dirigir, andar de bicicleta no começo e difícil e depois vai melhorando com a prática. =D

Mas então, hoje vou mostar um plugin simples, que vai facilitar bastante, ele serve para verificar se o usuário está logado ou não, caso não esteja direciona para a tela de login.

Para que você não tenha que colocar a verificação em todo metodo init de seus controladores.

Esse plugin é ideal para você utilizar no sistema de administração do site.

Então vamos lá ao código!

No meu caso a pasta de plugins fica dentro da pasta application então seria mais ou menos assim.

application/plugins/HasIdentity.php

class Application_Plugin_HasIdentity extends Zend_Controller_Plugin_Abstract
{
   /*
    Nome do módulo, controlador e ação que o usuário terá acesso caso não esteja logado.
    */
   const module      = 'admin';
   const controller  = 'auth';
   const action      = 'login';

   public function preDispatch(Zend_Controller_Request_Abstract $request)
   {
      $module     = $request->getModuleName();
      $controller = $request->getControllerName();
      $action     = $request->getActionName();

      // Verifica se o usuário não está logado
      if(!Zend_Auth::getInstance()->hasIdentity()) {
         // Verifica se a requisição é diferente do permitido
         // Se for diferente rotea para a página de login
         if($module != self::module && $controller != self::controller && $action != self::action) {
            $request->setModuleName(self::module);
            $request->setControllerName(self::controller);
            $request->setActionName(self::action);
         }
      }
   }
}

Ai depois é so registrar o plugin no meu caso uso no bootstrap ficando assim.

public function _initPlugins()
{
   $frontController = Zend_Controller_Front::getInstance();
   $frontController->registerPlugin(new Application_Plugin_HasIdentity());
}

Pronto! Agora que você registrou o plugin só atualizar a página e experimentar. =D

Abraços,

John Marques

olha nós aqui de novo =D, hoje vou mostrar como traduzir as mensagens de validação do Zend, primeiro baixe a versão full do zend, eu utilizo 1.10.

Não vou ensinar como fazer a instalação e configuração do Zend Framework por que existem diversos posts falando sobre isso, então é só dar um googada. =D

Depois de descompactado seu arquivo na pasta “resources”, existe a pasta “languages”, copie essa pasta para a pasta “application”.

Agora vamos ao código, no arquivo Bootstrap.php, insira o seguinte método.

protected function _initTranslate()
 {
 try {
 $translate = new Zend_Translate('Array', APPLICATION_PATH . '/languages/pt_BR/Zend_Validate.php', 'pt_BR');
 Zend_Validate_Abstract::setDefaultTranslator($translate);
 } catch(Exception $e) {
 die($e->getMessage());
 }
 }

Pronto! =D

Agora basta criar o formulário e fazer a validação =D

Quanto tempo heim?

Pois então hoje estava mexendo com um classe para fazer interação com o Twitter sem o usar autenticação via oAuth, então fiz em cURL, e gostaria de compartilhar com vocês. =D

Achei dois artigos na internet que me ajudarão a fazer, no fim passo a referência.

Então vamos lá!

Arquivo:  TwitterStatuses.php

<?php
/**
 * Classe de manipulação do status do usuário no Twitter
 *
 * @author John Marques
 *            john@webcomcafe.com.br
 */
class TwitterStatuses
{
 /**
 * Usuário do Twitter
 * @var string
 */
 private $username;

 /**
 * Senha do usuário do Twitter
 * @var mixed
 */
 private $password;

 /**
 * Usuário e Senha já formato para o CURL
 * @var mixed
 */
 private $userpwd;

 /**
 * Vetor com as url que servirão para interagir com o Twitter
 * @var array
 */
 private $url = array(
 'update'         => "http://TwitterStatuses.com/statuses/update.xml",
 'user_timeline' => "http://TwitterStatuses.com/statuses/user_timeline.xml"
 );

 /**
 * Seta os valores dos membros da classe
 * @param string $username
 * @param string $password
 */
 public function __construct($username, $password = '')
 {
 self::setUsername($username);

 if($username != '' && $password != '')
 {
 self::setPassword($password);
 }
 }

 /**
 * Seta o valor do membro $username
 * @param string $value
 */
 public function setUsername($value)
 {
 $this->username = $value;
 }

 /**
 * Seta o valor do membro $password
 * @param string $value
 */
 public function setPassword($value)
 {
 $this->password = $value;
 $this->userpwd  = $username . ':' . $value;
 }

 /**
 * Atualiza o status do perfil do usuário no TwitterStatuses
 * @param string $message
 */
 public function update($message)
 {
 if($this->userpwd == '') {
 trigger_error("O membro \$userpwd não pode ser nulo.", E_USER_ERROR);
 return false;
 }

 $curl_handle = curl_init();
 curl_setopt($curl_handle, CURLOPT_URL, $this->url['update']);
 curl_setopt($curl_handle, CURLOPT_CONNECTTIMEOUT, 2);
 curl_setopt($curl_handle, CURLOPT_RETURNTRANSFER, 1);
 curl_setopt($curl_handle, CURLOPT_POST, 1);
 curl_setopt($curl_handle, CURLOPT_POSTFIELDS, "status=$message");
 curl_setopt($curl_handle, CURLOPT_USERPWD, $this->userpwd);
 $buffer = curl_exec($curl_handle);
 curl_close($curl_handle);

 $ResponseXML = simplexml_load_string($buffer);

 if(isset($ResponseXML->error) && $ResponseXML->error != '') {
 return false;
 } else {
 return true;
 }
 }

 /**
 * Retorna os últimos tweets do usuário no TwitterStatuses, não é necessário logar
 */
 public function user_timeline()
 {
 $curl_handle = curl_init();
 curl_setopt($curl_handle, CURLOPT_URL, $this->url['user_timeline'] . '?screen_name=' . $this->username);
 curl_setopt($curl_handle, CURLOPT_HEADER, 1);
 curl_setopt($curl_handle, CURLOPT_TIMEOUT, 30);
 curl_setopt($curl_handle, CURLOPT_RETURNTRANSFER, 1);
 $buffer = curl_exec($curl_handle);
 curl_close($curl_handle);
 // Encontra a primeira ocorrência de <?, para que se retorne somente o xml
 $data = strstr($buffer, '<?');
 // Interpreta o xml e transforma em objeto
 $ResponseXML = simplexml_load_string($data);

 if(isset($ResponseXML->error) && $ResponseXML->error != '') {
 return false;
 } else {
 // Retorna os status como vetor
 return $ResponseXML->status;
 }
 }
}
?>

A classe possui  cinco métodos,  são eles:

• __construct( $username, $password = ” );
  Seta o usuário e senha do usuário que irá ser “manipulado”,  é obrigatório o parâmentro $username,  caso não seja informado o parâmentro $password, não se consiguirá “Twittar”.
  Fiz dessa forma por que pode haver o caso de você programador não necessitar fazer tweet, somente buscar os últimos tweets do usuário

• update( $message );
  Faz a atualização do status do usuário no perfil do orkut, ou popularmente faz um Tweet.
  É verifica se o usuário informou o usuário e seha, caso não seja informado, gera um Fatar error como esse:
  “Fatal error: O membro $userpwd não pode ser nulo. in C:\wamp\www\espaco_cidadania\twitter\TwitterStatuses.php on line 78″
• user_timeline();
  Retorna os últimos tweets postados pelo o usuário.
• setUsername(); e setPassword();
  São métodos para setar os valores dos membros $username, $password e $userpwd

Agora que já está explicado os métodos da classe, vamos aos exemplos.

Retornando os Tweets

<?php
// Requer o arquivo da classe
require_once('TwitterStatuses.php');

// Inicia o objeto e passa o usuário
$twitter = new TwitterStatuses('nome_do_usuario_no_twitter');
// Retorna a Timeline
$status  = $twitter->user_timeline();

// Verifica se o retorno está OK
if($status) {
 // Número de Tweets
 $num_status = count($status);

 // Faz o loop
 for($i=0; $i<$num_status; $i++) {
 // Tweet Corrente
 $current = $status[$i];

 // Exibe alguams informações
 echo 'id:' . $current->id . '<br />Date:'.date('d/m/Y H:i:s', strtotime($current->created_at)).'<br />Messagem: ' . utf8_decode($current->text);

 // Exibe os dados retornado no Tweet corrente
 echo '<br /><br />Resposta do Twitter<br />------------------------------------------<br />';
 print_r($current);
 echo '<br /><br /><br />';
 }
}
?>

Atualizando o status do Twitter

<?php
// Requer o arquivo da classe
require_once('TwitterStatuses.php');

// Inicia o objeto e passa o usuário
$twitter = new TwitterStatuses('nome_do_usuario_no_twitter', 'senha_do_usuario');

// twita
if($twitter->update('Twitando pela classe TwiterStatuses')){
 echo 'Tweet realizado com sucesso';
} else {
 echo 'Não foi possível twittar';
}

Então pessoal é isso ai,  até a próxima

Referência:
http://www.marksanborn.net/howto/getting-your-twitter-updates-with-curl
http://morethanseven.net/2007/01/20/posting-to-twitter-using-php.html

Seguinte fiquei bem feliz agora, então resolvi postar um artigo falando sobre o assunto.

Instalei  o VirtualBox para testar alguns Linux, para aprender algumas coisas. Sou acostumado a usar a distrubuição da Red Hat, gosto dela, então instalei Fedora 12 Constantine, mas ai veio um problema não consiguir acessar como root, no ambiente gráfico, fiquei muito mordido por que tinha que fazer algumas coisas com Shell, que pelo ambiente gráfico seria muito mais simples, então dei um olhada na internet  para ver o que a comunidade falava.

Então descobri que eles pediam para que alterassem um arquivo e comentasse uma linha. O arquivo é /etc/pam.d/gdm e comentasse a linha auth required pam_succed_if.so user != root quiet, então veio o problema não funcionava, então acabei deixando de lado, mas hoje estava mexendo no Fedora e me surgiu o mesmo problema do começo, a dificuldade em fazer algumas coisas no ambiente gráfico sem o usuário root, então resolvi fuçar e tentar resolver de uma vez, acabei que consegui \0/. Descobri que além do arquivo /etc/pam.d/gdm, existe outro arquivo que estava restringindo o acesso, era o arquivo /etc/pam.d/gdm-password, então bastou comentar a linha auth required pam_succed_if.so user != root quiet para funcionar.

Então pessoal está ai a dica =D

Abraços,

John Marques

Um exemplo: Você tem uma matéria que fala sobre “notebooks” e quer citar a página de uma empresa de notebooks mas não quer dar crédito a ela, era só colocar o link da seguinte forma:

 <a rel="nofollow" href="//www.exemplo.com.br">Visitar a página de exemplo</a> 

Mas este mesmo atributo começou a ser usado também para esculpir o Pagerank de um site em uma técnica chamada de “Pagerank Sculpting”.

Esculpir o Pagerank seria por exemplo: Você tem um site e logicamente não necessita que o Google dê maior relevância a página de contato do seu site, porém, todas as suas páginas tem um link para a página de contato. Então bastava adicionar o atributo nofollow ao link “contato”, assim a relevância dos outros links aumentava.

Isso podia ser feito de uma forma mais… mais… maligna específica no seguinte exemplo:

Você possui uma matéria falando sobre pássaros, e nesta matéria tem 10 links diferentes. Em nove desses links você usava o atributo nofollow e único link que não possuía o nofollow era o que levava a maior relevância nos mecanismos de pesquisa. Entenderam a jogada? Pensem mais um pouquinho então.

Agora o Google anunciou que não mais irá considerar o atributo nofollow para estes fins (Pagerank sculpting) e sim apenas para o propósito inicial, não seguir os links.

Então, podem continuar usando este atributo, por exemplo, nos links de comentários em um site…

Nos links daquela empresa que não gosta mas teve que citar…

Mas quem era fã da técnica de Esculpir o Pagerank terá que pensar em links dentro de um iframe ou links em javascript complexos para que o Google não os siga.

olha eu aqui de novo. rs.

Seguinte hoje vou falar sobre o array_diff, que foi uma mão, melhor um braço na roda para mim, pois estou trabalhando com URL amigáveis em um sistema e ele me ajudou muito, então vamos lá.

Extraído do Manual PHP
array_diff
“Analisa as diferenças entre arrays”

Então, ai você me pergunta para que? Ai eu digo imagine que você tem elementos em um vetor e quer saber quais dele não contém em outro (lembrei das aulas de matemática da escola contém e não contém, haushhuas), então no meu caso o que aconteceu foi o seguinte, eu tinha uma URL e queria saber as partes dessa que não contia na variavel que contém a url raiz.

Assim,

Ex.:

Variável contendo a url raiz do site

$url_raiz = 'http://www.johnmarques.com.br/novo_site/';

ai por exemplo o url requisitada nesse momento seja http://www.johnmarques.com.br/novo_site/2010/,  então eu queria que sistema soubesse que a diferença era a “pasta” 2010, dei um olhada por cima no Senhor da Internet, procurando por diferença entre Strings, mas não achei muita coisa ai, pensei putz por que não quebra a url em partes de um vetor e depois fazer uma comparação, então foi isso que fiz, e Bingo! ;D

Vou demonstrar mais ou menos como fiz.

Antes de explicar, vale lembrar que a função array_diff não faz diferenciação entre vetores multi-dimensionais então você tem que diferenciar vetores no mesmo nível.

Extraído do Manual PHP
Nota: Note que esta função faz compara apenas uma dimensão de um array com dimensão n. Mas, obviamente, você pode comparar outras dimensões usando array_diff($array1[0], $array2[0]);.

e que também ele faz uma comparação igual a operador de comparação de semelhança (===), sendo assim mais ou menos isso, (string) $elem1 === (string) $elem2.

Outra coisa que vale resaltar e que ele verifica os elementos que vetor 01 e que não contém no vetor 02 e as chaves desses elementos são preservadas.

Agora o exemplo.

fiz mais ou menos assim:

<?php
$url_raiz = 'http://www.johnmarques.com.br/novo_site/';
$url_req = $_SERVER['REQUEST_URI']; // No caso o valor seria /novo_site/2010/, perceba que não tem o dominio, então eu fiz assim na variavel $url_raiz, dividi em duas

$url_dominio = 'http://www.johnmarques.com.br';
$url_base = '/novo_site/';
$url_raiz = $url_dominio . $url_base;
$url_req = $_SERVER['REQUEST_URI'];

// Ai ficou mais fácil fazer a comparação
function retorna_vetor($url)
{
   $partes = explode('/',$url);
   $i=0;
   $partes_new = array();

   foreach($partes as $key => $value)
   {
      if($value != '')
      {
          $partes_new[$i] = $value;
          $i++;
      }
   }

   return $partes_new;
}

// faço o mesmo processo no outro
$vetor_req = retorna_vetor($url_req);
$vetor_raiz = retorna_vetor($url_base);

print_r(array_diff($vetor_req,$vetor_raiz)); // provávelmente irá retorna array(1=>2010)
?>

ai ficou fácil,

espero que tenha alguma serventia, para mim pelo menos foi um braço na roda, se alguém tiver um forma melhor de ser feito pode comentar e explicar como funcionaria.

Abraço a todos,

John Marques