En esta entrada, y después de instalar NetBeans 6.8 beta, vamos a probar su funcionamiento con PHP y XDEBUG.

La instalación de NetBeans 6.8 beta es similar a NetBeans 6.7 en los tres sistemas operativos (Mac, Linux y Windows).

Véase la entrada correspondiente. (JDK + Netbeans 6.7 separados en Windows) en este este blog.

Por otro lado y en lo que relacionado con PHP 5, tengo montado XAMPP 1.7.21 para Windows que instala de forma facil y simultánea

• Apache 2.2.12 (IPv6 enabled) + OpenSSL 0.9.8k
• MySQL 5.1.37 + PBXT engine
• PHP 5.3.0
• phpMyAdmin 3.2.0.1
• Webalizer 2.21-02 + GeoIP lite
• FileZilla FTP Server 0.9.32
• msmtp 1.4.17

Una vez instalados XAMPP y  NetBeans 6.8, fijaremos determinadas caracteristicas del entorno para trabajar con PHP y xDEBUG.

En primer lugar, si en una sesión de NetBeans 6.8 hacemos Herramientas, Opciones y seleccionamos la pestaña PHP, aparecerá

Desde esta pantalla tendremos que indicar dónde se encuentra el intérprete de PHP5 al IDE, en mi caso es la carpeta C:\xampp\php

por ello,

Ahora, en el supuesto de tener instalado XAMPP, detenemos los servicios desde el panel de control, localizamos el fichero php.ini en c:/wampp/php/ y lo abrimos.

Buscamos

zend_extension = “C:\xampp\php\ext\php_xdebug.dll”

y descomentamos. Habría que decir aquí que la versión de la librería xdebug.dll que incorpora el paquete de php con XAMPP funciona perfectamente. Cabría sin embargo ir a xdebug y descargar la versión mas actualizada. Y finalmente, sustituir una por otra, pero de momento vamos a utilizar php_xdebug.dll por defecto.

Buscamos y descomentamos o modificamos las líneas que sigue a los valores en ella indicados:

xdebug.profiler_output_dir = “C:\xampp\tmp”

xdebug.profiler_enable = 1

xdebug.remote_handler = “dbgp”

xdebug.remote_host = “localhost”

xdebug.remote_port = 9000

xdebug.remote_enable = “On”

y finalmente, descomentamos

display_errors = On

Cerramos ahora php.ini salvándolo, e iniciamos xampp.

Si ahora hacemos “Admin” desde el panel de control de XAMPP y luego phpinfo() comprobaremos que ya está montado el módulo xdebug.

Uzun suredir Windows Server 2003 isletim sistemi uzerinde barindirdigim IIS‘den ASP.NET ve FastCGI ile PHP destegi veren server’imi tamamen Ubuntu Server‘a tasimaya karar verdim. Apache2, PHP5 ve MySQL kullaniyor olacagim. Bunun temel nedenlerinden birkaci lisans sorunu ve Linux’un terminal konusunda Windows’tan cok daha ustun olmasi, dolayisiyla bana PDA‘den bile server’imi yonetme olanagini saglamasi.

Oncelikle dun (Kasim 4 2009) su anki server’imi ve barindirdigim sistemi/siteleri hicbir sekilde etkilemeyecek sekilde ikinci bir bilgisayara Ubuntu Linux yukledim, Apache, PHP ve MySQL calisir durumda. Simdilik detayli konfigurasyonlarla ugrasiyorum, FTP kurulumu, VirtualHost konulari gibi.

→ Ilk Izlenimler

En cok hosuma giden ozellik SSH kullanarak sistemdeki her seyi Broadband bir internet baglantisi olmasina gerek kalmadan kontrol edebilmem. Kampus kutuphanesinden son derece hizli bir sekilde terminal’den konfigurasyon yapiyorum, inanilmaz.

Microsoft IIS’ten aliskin oldugum Start>Control Panel>Administrative Tools>Internet Information Systems gibi tanimlar cok uzak. Ubuntu Server 9.10 varsayilan olarak GUI’siz geldigi icin her seyi simdilik terminal’den yapmak zorundayim.

Zorlanmadim denemez. Bir gundur FTP server icin virtual kullanicilar yaratmaya calisiyorum. Tabi ki onca artinin yaninda eksilerinin de olmasini bekliyordum ancak bu kadar fazla sorunla karsilasacagimi tahmin etmiyordum!

Simdilik bu kadar, kurulumu yaptiktan sonra 1 ay kadar ikinci server’imi deneme icin acik birakacagim, bu surec sonunda herhangi buyuk bir problemle karsilasmazsam, su anki kullandigim ana server’i tamamen Ubuntu’ya adayacagim.

Benim gibi Microsoft .NET ile yasamini gecirmis biri icin inanilmaz bir adim olacak.

Gelismeleri yazmaya devam edecegim.

Este artigo mostra bem claramente a construção de uma classe em PHP5, esta classe visa construir um componente txt para PHP5, lembre-se que esta é uma classe básica, que de início parece desnecessário construí-la, pois é bem mais fácil faze-lá diretamente em HTML, todavia esta classe servirá de base para classes mais complexas. O seja, não se preocupe com a utilidade da classe agora e sim no seu funcionamento.

Uma classe é algo simples, entenda melhor sobre Orientação a Objeto na sessão POO deste site, pois aqui já partiremos para a construção de uma classe em PHP5 pulando os conceitos básicos sobre o assunto.

Para começar crie duas pastas, uma na raíz do site com o nome “classes”, esta pasta conterá todas as suas classes, é so por organização mesmo, mas faça, pois quanto mais organizado for, mais fácil será localizar as classes que criaremos, que não serão poucas.

Crie uma segunda pasta com o nome “html” dentro da pasta classes, dentro desta pasta colocaremos nossas classes básicas de html, não se preocupe, depois a gente vai entender melhor isso.

Pronto, com as pastas feitas, criaremos aqui uma página chamada classe_compTxt.php e salvaremos dentro da pasta /classes/html/.

E vamos ao código da página:

<?php

//Classe CompTxt – escreve texto em html.

// aqui nos começamos nossa classe
class compTxt{

/*Estes são os atributos da classe, notem que os atributos são precedidos da palavra “private”, isto significa que esses atributos só serão acessados pela própria classe, ou seja, não será possível acessá-los de outro lugar a não ser esta classe, fique calmo você entenderá melhor mais adiante. */

private $face;
private $size;
private $color;
private $negrito;
private $texto;

/*Este Método é chamado de construtor, pois ele é executado quando se instancia esta classe, ou seja, podemos realizar várias ações quando a classe for instanciada, basta colocar os códigos aqui e pronto. */

public function compTxt(){

}

/* Aqui é que resolvemos o problema de se alcançar os atributos da classe, notem para se modificar o conteúdo dos atributos usa-se o método set, e para acessar o conteúdo usa-se o método get, então dessa forma só acessa-se os atributos da classe pela própria classe, os métodos get e set ficam disponíveis para todos, criando assim um acesso controlado aos atributos. */

public function set_face($Vface){
$this->face = $Vface;
}
public function get_face(){
return $this->face;
}

public function set_size($Vsize){
$this->size = $Vsize;
}
public function get_size(){
return $this->size;
}

public function set_color($Vcolor){
$this->color = $Vcolor;
}
public function get_color(){
return $this->color;
}

public function set_negrito($Vnegrito){
$this->negrito = $Vnegrito;
}
public function get_negrito(){
return $this->negrito;
}

public function set_texto($Vtexto){
$this->texto = $Vtexto;
}
public function get_texto(){
return $this->texto;
}

/* Este método é que realmente cria o html que nós queremos, e é muito simples mesmo, notem que o texto será formatado na criação. */

public function cria(){
echo “<font face=’$this->face’ size=’$this->size’ color=’$this->color’>”;
if ($this->negrito == “true” or $this->negrito == “True”){
echo “<b>”;
}
//escreve o texto
echo $this->texto;
if ($this->negrito){
echo “</b>”;
}
echo “</font>”;
}
}
?>

Pronto, nossa classe está pronta, agora nós criaremos uma instância desta classe, ou seja um objeto.

Na raíz do site crie agora uma página com o nome estudoTxt.php.

E vamos ao código:

<?php
//inclui a classe que criamos.
include_once(“classes/html/classe_compTxt.php”);
//instanciaremos nosso objeto
$txt = new compTxt();

//vamos setar os atributos do objeto
$txt->set_face(“verdana”);
$txt->set_size(“2″);
$txt->set_color(“Blue”);
$txt->set_negrito(true);
$txt->set_face(“Minha primeira classe básica em php5″);
// agora vamos criar o texto
$txt->cria();
?>

Está pronto, notem que foi bem mais trabalhoso do que criar o html, mas notem também que nosso objeto nos permitiu construir um texto em html sem escrever nada em html e nem intercalar código html com php, ficou apenas o código em php. Mais pra frente essa classe será muito importante para criação de classe bem mais complexas.

Bem, continuaremos falando sobre isso depois, quando acabarmos esse estudo você será capaz de construir páginas muito complexas com o uso de Orientação a Objeto, ficando assim muito simples e rápido, acredite!

Fonte: Código Fonte

Segue esquema que uso pra logar usuário com Kohana Auth.
Em breve postarei script completo para controle de usuário.

<?php
class User_Controller extends Controller {

	protected $auth;
	protected $session;

	public function __construct() {
		// não se esqueça de executar o construtor da classe parent
		parent::__construct();

		// Criando e/ou pegando instancia de Auth
		$this->auth = Auth::instance();

		// Usaremos a session para nossas mensagens de erro
		$this->session = Session::instance();
	}

	public function login() {

		// se o usuário já estiver logado como admin, redireciona para user/index
		if ( $this->auth->logged_in( 'admin' ) ) {
			url::redirect( 'user' );
		} else {

			$username = $this->input->post('username');
			$password = $this->input->post('password');
			$remember = (bool) $this->input->post('remember');

			//se username estiver vazio redireciona para tela de login
			if ( empty( $username ) ) {

				url::redirect( 'login' );

			} else {

				if ( $this->auth->login( $username, $password, $remember ) ) {

					// se logou com sucesso redireciona para área protegida
					if ( $this->auth->logged_in( 'admin' ) ) {

						url::redirect( 'user' );

					} else {
						// se usuario nao tem role admin, retorna erro e faz logout
						// logout redireciona pra tela de login
						$this->session->set( 'error_msg', 'Acesso negado.' );
						$this->logout();

					}

				} else {

					// login errado, seta erro e retorna pra tela de login
					$this->session->set( 'error_msg', 'Username e/ou senha inválidos.' );
					$this->session->set( 'field_values', $this->input->post() );
					url::redirect( 'login' );

				}
			}

		}

	}
}

I just spent a half hour playing with PHP5’s sessions and would like to disperse some knowledge.  My first question …

How can you check if a session has been started?

session_id() will return false if session_start() has not been called.  However, if you’ve closed the session with session_write_close() / session_commit() and then re-started it, the old ID will be there.  So except for detecting that session_start() has never been called, you can’t reliably tell at all.

Are session_start() calls reference counted (pushed and popped) ?

No, they aren’t ref-counted and subsequent start requests will result in warnings.  Likewise calling session_write_close() multiple times does nothing, but it also doesn’t generate a warning.  This means that unless you’re in the entry-point of a script, you shouldn’t be calling session_start() without first checking for session_id() to see if it’s been started already.  Of course, since that doesn’t always work, it’s a crap shoot!

Why open and close the session manually and/or multiple times at all?

In most PHP installations a session is implemented as a file.  That file is located based on the session identifier which is probably the file name itself.  So starting a session opens that file for random access (read/write) and committing it causes it to be closed.  Thus there are inherent performance issues with auto-starting sessions and simply “leaving them on and open all the time”.  Your script will close sessions when it ends, but why not open and close only if you need to read/write?  Not doing this also causes contention on the user side with sites where resources are generated by PHP.  If each request has to wait for the last to complete you effectively get a slow, serialized experience.

Após ler alguns livros sobre PHP5, OOP e Design Patterns eu ainda não tinha encontrado uma situação em que usar interfaces ajudaria. Bom, eu acho que eu não li direito.
Segue um bom modo de usar as interfaces que encontrei lendo o blog de Brandon Savage.

Interfaces são coleções de métodos abstratos. Não se pode programar nada nas interfaces, você apenas deve definir uma estrutura para os objetos que vão implementá-la e todos os seus métodos devem ser públicos. Segue um exemplo de interface:

interface DatabaseI
{
    public function __construct();

    public function connect();

    public function query();
}

Agora veja essa classe:

class semTypeHinting
{
    public function __construct($databaseO)
    {
        if(method_exists('connect') AND method_exists('query')) {
            $databaseO->connect();
	    $databaseO->query();
        }
    }
}

Nós temos que saber se os métodos estão implementados ou não antes de executá-los. É aí que as interfaces podem lhe ajudar. Veja este exemplo:

class comTypeHinting
{
    public function __construct(DatabaseI $databaseO)
    {
        $databaseO->connect();
	$databaseO->query();
    }
}

Neste exemplo nós exigimos no construtor que o objeto passado esteja implementando DatabaseI. Como você tem de implementar as interfaces exatamente como definiu a estrutura, nós sabemos que os métodos connect() e query() estão disponíveis.

As interfaces ajudam quando precisamos saber se os métodos estão ou não estão implementados.

Se você tentar passar qualquer outra coisa que não implemente o objeto DatabaseI receberá um erro fatal:

Argument 1 passed to comTypeHinting::__construct() must implement interface DatabaseI

Abraço.

O método mais simples de se integrar qualquer aplicação com o magento é pelo Web Service.

A idéia da equipe de desenvolvimento do magento é deixar todas as funcões da administração do sistema disponíveis também no Web Service. (Ih, vai demorar…)

Vamos a um exemplo simples, quero listar os produtos de uma categoria específica.

A categoria se chama “Vitrine” e está inativa no magento. Quando eu quiser que um produto apareça no nosso script, é só associá-lo a esta categoria.

Primeiro vamos adicionar um usuário e uma role (algo como “cargo”) no magento.

1. Vá em System -> Web Services -> Roles e crie uma nova role chamada “general”.
2. Na aba “Role Resources” defina “All” no campo “Resource Access”.
3. Vá em System -> Web Services -> Users e adicione o usuário “magento” com a senha “123456″.
4. Na aba “User Role” associe o usuário “magento” a role “general”.

Agora vamos criar um projeto do Zend.

1. Baixe o zend em http://framework.zend.com/. Eu estou usando a versão 1.9.3.
2. Descompacte e vá para o diretório bin.
3. Execute: (zf.bat para Windows)

zf.sh create project integration

Agora mova o diretório integration para o diretório root do seu servidor.

Pronto, vamos programar! O plano é chamar o método no Index_Controller e ter um array com os dados no index view.

Editando o controller em application/controllers/IndexController.php

<?php
class IndexController extends Zend_Controller_Action
{

    public function init()
    {
        /* Initialize action controller here */
    }

    public function indexAction()
    {
    	// Opening a client connection
        $client = new Zend_XmlRpc_Client('http://magento/api/xmlrpc/');

		// Calling method login
		$session = $client->call('login', array('magento', '123456'));

		// call method category.assignedProducts with parameters CategoryID = 9 and StoreID = 1
		// Category 9 is 'Vitrine'
		$product_list = $client->call('call', array($session, 'category.assignedProducts', array('9','1')));

		// iterate product list to get detailed information with method product.info
		foreach( $product_list as $product ){
			$products[] = $client->call('call', array($session, 'product.info', $product['product_id']));
		}

		// ending session
		$client->call('endSession', array($session));

		// setting variable products for the view
		$this->view->products = $products;
    }
}

Porque estou usando XML-RPC? porque não consegui com SOAP e não faço a mínima idéia do motivo.

Editando o view que está em application/views/scripts/index/index.phtml

<pre>
<? print_r($this->products); ?>
</pre>

Não se espante com a complexidade da minha view.

Pronto. Se você associou o produto a categoria vitrine e está buscando o id correto da categoria você terá um array com detalhes dos produtos dela.

Acesse integration/public no browser e verá o resultado.

Espero ter ajudado. Até mais.

Este é o primeiro artigo de uma série sobre a SPL que pretendo escrever.

O PHP 5 vem com várias interfaces pré definidas. Uma delas é a ArrayAccess, que permite que você manipule um objeto como se fosse um array.

Definição:

ArrayAccess   {
 /* Methods */
 abstract public boolean offsetExists ( string $offset )
 abstract public mixed offsetGet ( string $offset )
 abstract public void offsetSet ( string $offset , string $value )
 abstract public void offsetUnset ( string $offset )
}

• offsetExists: checa se existe um valor para o offset e tem que retornar um valor booleano.
• offsetGet: retorna o valor do offset;
• offsetSet: seta ou sobrescreve o valor de um offset;
• offsetUnset: apaga o offset.

Parece confuso não é? Tudo bem, vamos a um exemplo prático:

class Livros implements ArrayAccess {

 private $titulo;
 private $autor;

 public function offsetExists( $offset ) {
 return isset( $this->$offset );
 }

 public function offsetSet( $offset, $valor ) {
 $this->$offset = $valor;
 }

 public function offsetGet( $offset ) {
 return $this->$offset;
 }

 public function offsetUnset( $offset ) {
 unset( $this->$offset );
 }
} 

$livros = new Livros;

$livros['autor']		= 'Alvaro Guimaraes';
$livros['titulo']		= 'A volta de quem não foi!';

print_r( $livros );

Isso deverá imprimir:

Livros Object
(
    [titulo] => A volta de quem não foi!
    [autor] => Alvaro Guimaraes
)

Referências:

1. http://www.phpmag.ru/2009/08/02/php5-predefined-interfaces/#array.access
2. http://www.php.net/manual/en/class.arrayaccess.php
3. http://www.phpro.org/tutorials/Introduction-to-SPL-ArrayAccess.html
4. http://mcarthurgfx.com/blog/article/arrayaccess-interface-in-php

Someone mentioned to me that they couldn’t use PHP5-style object constructors when using the WP Widget API. I looked into it, and it turns out it does work. Example:

class My_Widget extends WP_Widget {
	function __construct() {
		$widget_ops = array( 'classname' => 'css-class', 'description' => 'Description' );
		parent::__construct( 'css-class', 'Title', $widget_ops );
	}
	// Rest of your widget subclass goes here
}

The key is using parent::__construct() instead of $this->WP_Widget().

Quando migrei os dados de um servidor Debian 4 com PHP4 e Firebird 1.5 para Ubuntu 8.04 com Firebird 2 tive problemas em tratar a exibição de datas retornadas do banco. Como tenho muitos scripts que dependem do formato da data antiga (Mês/Dia/Ano) resolvi alterar diretamente no servidor o formato, ao invés de alterar os vários scripts que tinha.
A solução foi adicionar ao arquivo /etc/php5/apache2/php.ini a diretiva [interbase], e colocar o novo formato de data que eu queria. Para isso executei os seguintes comandos (como usuário root):

vim /etc/php5/apache2/php.ini

E no final deste arquivo eu inseri o seguinte conteúdo:
[interbase]
ibase.dateformat="%m/%d/%Y"

Restartei o Apache
/etc/init.d/apache2 restart

E pronto..tudo funcionou perfeitamente como era antes.

Espero que este post seja útil.