Curiosidade da versão do Cake 3 é a mudança de nome que provavelmente foi dada por causa da licensa do “PHP”.

  3. The name "PHP" must not be used to endorse or promote products
     derived from this software without prior written permission. For
     written permission, please contact group@php.net.

Veja toda a Licensa do PHP aqui.

Ou seja só pode usar o nome PHP em algum produto com autorização do PHP, não sei se as outras versões possuem essa autorização mas todavia, acho que o Cake está encaminhando a mudar o nome.

O released CakePHP 1.2.4.8284, é de bug fixes, com pequenas mudanças, e alguns bugs fixed, assim como melhorias nos tests. Todas as mudanças na versão do CakePHP 1.2 pode ser visto no changelog.

Enquanto a versão Cake 3, está sendo desenvolvida utilizando os recursos do PHP 5.3, como funções anonimas e namespace, que irão ajudar muito principalmente no desenvolvimento de plugins que será muito mais fácil, pois será agora possível a criação de pacotes. Assim como o conflito com o nome de classes que não irão correr mais, e isso é um grande ponto.

A versão Cake3 será totalmente reformulada e vale a pena acompanhar o repositório o que está por vir.

Em paralelo está sendo desenvolvido o CakePHP 2, que será um refactoring do código do CakePHP 1.2 para PHP 5 para rodar em strict com o PHP 5.

Database Config

No config/database.php, onde definimos a conexão a base de dados do CakePHP, é possível definir nomes de atributos que serão os nomes do tipo de conexão a base de dados.

Exemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

< ?php
class DATABASE_CONFIG {
 
	var $default = array(
		'driver' => 'mysql',
		'persistent' => false,
		'host' => 'localhost',
		'login' => 'root',
		'password' => 'root',
		'database' => 'abccc',
		'encoding' => 'utf8',
	);
}
?>

O importante aqui é definir o hash enconding no array do attributo da sua configuração de banco, no caso foi definido utf8 (sem o hífen).

Aplicação Charset

No arquivo config/core.php, existe a configuração de encoding a ser definida para aplicação:

1
2
3
4

/**
 * Application wide charset encoding
 */
	Configure::write('App.encoding', 'UTF-8');

Sete nela o mesmo encode que você está usando ao longo da aplicação.

Charset do HTML

Outro local que definimos o encode da aplicação agora no caso o encode do HTML, é no helper Html, no layout verificar o:

1

< ?php echo $html->charset(); ?>

Por padrão o arquivo views/layouts/default.ctp já contei a impressão do meta charset, e não é necessário passar parâmetro para o mesmo, visto que já foi definido no config/core.php o encoding default da aplicação, logo o HtmlHelper pega o que foi definido no config/core.php.

Se o seu arquivo de layout não contem a sua adição pode ser necessária.

Database

Por último se continuar ainda com problemas de encoding, é necessário verificar seu banco de dados criado, verifique se o mesmo está setado com o encode esperado, assim como as tabelas e os atributos do tipo string estão também usando o mesmo encode.

Files

Outra verificação a ser feita é o encode dos arquivos, vale lembrar que os arquivos PHP devem estar no mesmo encode do resto da aplicação, para verificar isso no linux você pode usar o comando file: file arquivo.php, ele irá enformar o encode do arquivo, caso esteja errado converta o arquivo para o encode correto.

Esses processos são triviais ao longo do desenvolvimento com o CakePHP, e para aqueles que estão com algum problema provavelmente, algum desses processos descritos devem estar levando a sua aplicação CakePHP a apresentar esse tipo de error.

Para visualizar o material e fazer o download, acesse esse link.

Com este, conseguimos quando fazemos retrive em algum modelo, fazer com que ele traga justamente aquilo que achamos pertinente, ou seja, apenas o resultado desejado, com isso poupando dados redundantes, assim como melhorando a performance por o modelo deixar, de trazer relacionamentos que não são necessários.

O uso do mesmo no CakePHP, é muito simples, basta chamar ele no modelo, que julga pertinente, ou adicionar no AppModel para que todos os modelos herdem esse behavior, Countaible.

1
2
3

class AppModel extends Model {
    public $actsAs = array('Containable');
}

ou on the fly:

1

$this->Modelo->Behaviors->attach('Containable');

Após a importação seu uso é simples, imaginamos um ambiente onde temos os seguintes modelos:

Post, User, Comment, Tag, onde:

1
2
3

Post belongsTo User
Post hasMany Comment
Post hasAndBelongsToMany Tag

Agora supúnhamos que desejamos fazer uma listagem dos últimos posts, logo só precisamos exibir os dados, do Post, o User que escreveu esse Post e as Tags desse post.

1
2

$this->Post->contain('User','Tag');
debug($this->Post->find('all', array('limit' => 10)));

outro exemplo:

1

     $this->Post->contain('Comment.author = "Gabriela"');

Com isso filtramos os resultados que o find do Post deve trazer, isso pode ser feito com diversos relacionamentos:

1
2

$this->User->contain('Profile', 'Scrap', 'Scrap.User', 'Album.Photo');
$this->User->find('all');

Conseguimos definir os relacionamentos entre os modelos que desejamos trazer, é uma boa alternativa para o:

1

$this->Modelo->recursive

Resumindo o Containable é sempre uma grande opção, na ora de usar o find, pois com eles conseguimos definir exatamente o que desejamos que o find traga para nós.

Então você agora pode ter um livro free (totalmente grátis), que satisfaça algumas de suas dúvidas mais avançadas em CakePHP, eu fiz o download do livro hoje mesmo, e já comecei a dar uma lida, quem está apto com inglês pode fazer uma fácil leitura do mesmo, para aqueles que não estão, proponho aqui para comunidade, se juntarmos para fazer uma tradução desse livro.

O download do livro de CakePHP, pode ser feito aqui, e o post da publicação de Matt Curry você pode conferir aqui.

Para usar o mesmo é muito simples no controller que vamos fazer o upload usamos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

	public function beforeFilter() {
		$this->FileUpload->fileModel = 'Attachment';
		$this->FileUpload->fields = array('name'=> 'file_name', 
										  'type' => 'file_type', 
										  'size' => 'file_size');
		$this->FileUpload->allowedTypes = array('image/jpeg',
											    'text/plain',
												'image/png',
												'application/msword',
												'application/zip',
												'image/gif',
												'image/bmp',
												'application/excel',
												'application/pdf',
												);
		$this->FileUpload->uploadDir = 'files' . DS . 'attachments';
		parent::beforeFilter();
	}

Onde $this->FileUpload->fileModel é o modelo que referencia onde vai ser salvo as informações do arquivo do upload, caso não seja necessário salvar no banco passe null para esse atributo.

$this->FileUpload->fields se referencia as campos do banco de dados que vai salvar as informações do arquivo.

$this->FileUpload->allowedTypes um array com os tipos de mime types permitidos para fazer o upload.

$this->FileUpload->uploadDir diretório no file system onde deve ser salvo o arquivo.

No seu action de cadastramento teremos:

1
2
3
4
5
6
7
8
9

	public function admin_add() {
		if (!empty($this->data)) {
			if ($this->Attachment->validates() && $this->FileUpload->success) {
				$this->Session->setFlash(__('The Attachment has been saved', true));
				$this->redirect(array('action'=>'index'));
			} else {
				$this->Session->setFlash(__('The Attachment could not be saved. Please, try again.', true));
			}
		}	}

Para editar o mesmo processo pode ser usado.

Para deletar:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

	public function admin_delete($id = null) {
		if (!$id) {
			$this->Session->setFlash(__('Invalid id for Attachment', true));
			$this->redirect(array('action'=>'index'));
		}
		$attachment = $this->Attachment->findById($id);
    	if ($this->FileUpload->removeFile($attachment['Attachment']['file_name'])){ 
			if ($this->Attachment->del($id)) {
				$this->Session->setFlash(__('Attachment deleted', true));
			}
    	} else {
			$this->Session->setFlash(__('Not found the file', true));
    	}
		$this->redirect(array('action'=>'index'));
	}

Segue o mesmo a seguir:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

< ?php
class ZipComponent extends Object {
 
	public $zipFile;
	private $zip;
	public $extractDirectory;
 
	public function setFile($zipFile) {
		$this->zipFile = $zipFile;
		$this->zip = new ZipArchive();
	}
 
	public function setExtractDirectory($extractDirectory) {
		$this->extractDirectory = $extractDirectory;
	}
 
	public function extract($zipFile = null, $extractDirectory = null) {
		if (!is_null($zipFile)) {
			$this->setFile($zipFile);
		}
		if (!is_null($extractDirectory)) {
			$this->setExtractDirectory($extractDirectory);
		}
		if ($this->zip->open($this->zipFile)) {
			$this->zip->extractTo($this->extractDirectory);
    		$this->zip->close();
 
    		return true;
		}
 
		return false;
	}
 
}
?>

Para utilizar o mesmo basta no controller usar:

1
2
3
4
5
6
7
8
9

public $components = array('Zip');
 
public function add() {
    if ($this->Zip->extract($zipFile, $directory)) {
        print 'yes';
    } else {
        print 'no';
    }
}

Preciso melhorar o component, verificar se o diretório tem permissão de escrita, verificar os arquivos dentro do zip que são válidos e excluir os não validos, mas por início ele está assim e funciona.

Rapid Application Development (Desenvolvimento rápido de Aplicações)

Tais como outros frameworks, cakephp, code ignator, o Zend Framework agora trás gerador de código, tudo graças ao Zend_Tool e o Zend_Application.

Com ele é possível agora fazermos diversas tarefas triviais do desenvolvimento de uma aplicação, tais como criar um novo projeto, criar controllers, views, models. Podendo ser feitas essas tarefas por linha de comando tal como mostra a imagem a seguir:

O Zend_Application provêm padrões de objetos para o bootstraping, sendo assim facilitando na hora da criação do mesmo, para se dar início ao desenvolvimento de projeto.

Essas novidades chamaram muita atenção, pois o que acabava se reclamando muito é da árdua tarefa de desenvolver com a Zend é a criação de todos os arquivos do desenvolvimento, por sua vez o Zend Framework buscando ser um framework RAD podemos se encorajar a continuar a usar esse bom framework para vários projetos até aqueles que temos pouco tempo de desenvolvimento, pois a arquitetura desse framework é muito boa, muito bem planejada e faz bom uso do POO.

Algo que ainda falta é os geradores de CRUD, que ao meu ver em pouco tempo teremos o mesmo integrado ao ZF.

Outras novidades dessa versão assim como a descrição do Zend_Tool e Zend_Application pode ser visto aqui.

3 – Strings

No PHP temos dois operadores de strings “” e ”.

3.1 – Strings literais, apenas texto:

1
2
3

< ?php
    $title = 'Título';
?>

Quando não temos variaveis no meu da declaração de string, é usável apenas aspas simples.

3.2 – String literais com aspas simples no texto:

1
2
3

< ?php
    $sql = "SELECT * FROM `newspaper` WHERE name LIKE 'Janeiro%'";
?>

3.3 – String com variáveis:

Quando temos que mostrar uma variável no meio do texto, o menor uso possível da concatenação é melhor

1
2
3
4

< ?php
    $message = "Hello, {$name} welcome!";
    $message = "Hello, $name welcome";
?>

O uso das chaves deixa mais visível a variável, porém as duas formas são apropriadas e aceitadas normalmente.

3.4 – String com múltiplas linhas:

1
2
3
4
5

< ?php
    $sql = 'SELECT * FROM newspapers AS N'
            . 'INNER JOIN images AS I ON (I.id=N.image_id)'
	    . 'INNER JOIN users AS U ON (U.id=N.user_id)';
?>

3.5 – String com concatenação:

1
2
3

< ?php
    $title = 'Welcome' . $name . ' ' . $link->logout;
?>

4 – Arrays:

Arrays são vetores de armazenação de dados, podendo ser vetores, matrizes. No PHP existem dois tipos de arrays, os arrays com índice numérico e os com índice com strings que também são chamados de hash, ou arrays associativos.

4.1 – Arrays numéricos:

Em arrays numéricos os elementos ficam um ao lado do outro, porém se for grande uma quebra de linha para manter o padrão de no máximo 80 caracteres por linha, para passar strings para o array, o uso de aspas simples se da.

1
2
3
4

< ?php
    $data = array(0, 'CakePHP', 'Zend', 2, 3, 'Cobaia', 'PHP', 
                       'Vinícius', 'Krolow');
?>

4.2 Array associativos:

Em mapas de array a quebra de linha após cada índice, deixa com uma maior legibilidade o código, e também se da o uso de aspas simples, para o nome da referencia, assim como para a string associada.

1
2
3
4
5

< ?php
    $fields = array('name' => 'Vinícius',
                    'surname' => 'Krolow',
                    'url' => 'http://cobaia.net');
?>

Múltiplos arrays

1
2
3
4
5
6
7
8

< ?php
    $fields = array('name' => 'Vinícius',
                    'surname' => 'Krolow',
                    'url' => 'http://cobaia.net',
                    'posts' => array('test' => 'test',
                                     'new' => 'new'),
    );
?>