Mar 8

Server-Side ActionScript no Flash Media Server

Escrito por Leonardo França em 1, 2.0, 3.5, 4, 6, action, Actionscript, Actionscript 3.0, Adobe, Aplicativos, app, AR, bar, BI, botão, C#, carregar, case, class, Curso, Cursos, Desenvolvimento, Documentação, engine, err, eval, exemplo, Exemplos, flash, flash media, Flash Media Server, Flash Player, Flex, FMS, for, function, html, ide, IE, if, image, int, Java, Javascript, Mac, mg, NaN, O, on, online, padrão, player, pt, RIA, Ria’s Geral, S+S, server, servidor, streaming, swf, TAT, Teste, UI, uint, web, XP @ 03 8th, 2012 | via http://www.leonardofranca.com.br | Sem comentários

Poucos sabem mas o Flash Media Server(versão Interactive) possui uma linguagem de servidor chamada Server-Side ActionScript ou ActionScript Communications(extensão .asc). O que permite recurso poderosos em seus aplicativos multimídia muito além de um simples streaming.
Server-Side ActionScript é o nome que Adobe deu para o JavaScript 1.5, o Flash Media Server possui uma engine de JavaScript para compilar e executar os scripts.
O Server-Side ActionScript é parecido mas não idêntico ao ActionScript 1.0, mas ambos são baseado no ECMAScript(ECMA-262) edition 3 language specification. O Server-Side ActionScript roda sob a engine SpiderMonkey da Mozilla que consta no Flash Media Server enquanto que o ActionScript 1.0 roda sob o AVM1(ActionScript Virtual Machine 1) no Adobe Flash Player. O SpiderMonkey implementa o totalmente o ECMAScript enquanto que a AVM1 do Flash Player não. A grande diferença entre os dois é que o Server-Side ActionScript é case-sensitive.
Portanto para quem já tem conhecimento de JavaScript, pode reaproveita-lo para usar no Flash Media Server, é possível utilizar a maioria dos recursos e ainda contar com os recursos exclusivos do Flash Media Server.

Vamos os primeiros passos para utilizar o Server-Side ActionScript no Flash Media Server. Uma maneira de testar seus scripts é usando o fms_console localizado no caminho:

INSTALATION FOLDERAdobeFlash Media Server 4.5webrootswfsfms_adminConsole.swf

Se você tiver o Adobe Flash Professional, pode abrir esse arquivo diretamente apenas dando dois cliques, caso contrario, abra pelo navegador. Ao ser aberto, devemos ter uma tela como essa:

Tela inicial do fms_adminConsole.swf

Basta entrar com o login e senha que você determinou no momento em que estava instalando o Flash Media Server que deveremos entrar para a seguinte tela:

Tela pos-login

Esse será seu melhor amigo ao desenvolver aplicativos com Flash/Flex e Flash Media Server. Por padrão, o Flash Media Server lê o seguinte diretorio:

INSTALATION FOLDERAdobeFlash Media Server 4.5applications

Esse caminho pode ser configurado modificando a linha “VHOST.APPSDIR” no seguinte arquivo:

INSTALATION FOLDERAdobeFlash Media Server 4.5conffms.ini

Criaremos um diretorio chamado “teste”, e dentro dele um arquivo chamando “main.asc” com o seguinte conteúdo:

PLAIN TEXT

JAVASCRIPT:

// ActionScript Communications Document
trace(“init app…”);

Agora no console, carregaremos nossa aplicação criando uma nova instância dela selecionando no combobox:

Na tela seguinte, basta dar um “enter”.

Deveremos ter o resultado do nosso trace na caixa de texto como na imagem:

Resultado do trace

Uma recomendação que faço é que você limpe a tela antes de executar novamente o script main.asc, basta clicar no botão Clear Log(1) e depois em Reload Application(2):

Alguns exemplos do que pode ser usado com o Server-Side ActionScript

Constantes

PLAIN TEXT

JAVASCRIPT:

// ActionScript Communications Document
trace(“init app…”);
const PI = 3.14;
trace(PI);

Expressões Regulares

PLAIN TEXT

JAVASCRIPT:

// ActionScript Communications Document
trace(“init app…”);
myRe = /d(b+)d/g;
myArray = myRe.exec(“cdbbdbsbz”);
trace(myArray);

Funções

PLAIN TEXT

JAVASCRIPT:

// ActionScript Communications Document
trace(“init app…”);
function teste()
return “to na funcao o/”;
trace(teste());
function factorial(n)
if ((n == 0)
}
trace(factorial(5));

Objetos

PLAIN TEXT

JAVASCRIPT:

// ActionScript Communications Document
trace(“init app…”);
var obj = id:“teste”,data:2,status:“ONLINE”,type:“admin”
trace(obj);
for(s in obj)
trace(s +” – “+obj[s]);

Array

PLAIN TEXT

JAVASCRIPT:

// ActionScript Communications Document
trace(“init app…”);
var arr = ["leo", "carol", "pam", "perla","carlinha"];
trace(arr);
function removeValueFromArray(arr, value)
var len = arr.length;
for(var i = len; i> -1; i–)
if(arr[i] === value)
arr.splice(i, 1);
}
return arr;
}
trace(removeValueFromArray(arr,“pam”));

Aviso importante, use esses recursos SOMENTE em ambiente de desenvolvimento. Em ambiente de produção, você derrubará todo mundo que estiver conectado ? sua aplicação.

Referência:
Documentação do Adobe Flash Media Server

Dez 13

Multiple Views com Spring Web MVC

Escrito por DClick Team em .NET, 1, 2.0, 3.5, 4, 6, action, apache, app, Apresentação, AR, Arquitetura, arte, auto, BI, C#, case, class, classe, cliente, código, control, conversor, dados, Design, development, dispatch, Diversos, Documentação, err, exemplo, Ferramenta, Flex, for, framework, Frameworks, Google, handle, html, ide, IE, if, int, interface, internet, j2ee, Java, JSF, library, map, mvc, NaN, O, on, Outros, padrão, Projetos, pt, rest, RIA, Ria’s Geral, S+S, Sem categoria, servidor, site, Software, Spring, SpringFramework, state, string, strings, Sun, tag, TAT, Tecnologia, Tema, tv, Twitter, UI, uint, web, XML, XP @ 12 13th, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários

Twitter!

Uma das vantagens de utilizar a arquitetura do Spring para implementar projetos Web, é fazer uso do Sprin-WEB-MVC. Quem já usou sabe que isso é uma vantagem a se considerar quando for feita a escolha das tecnologias e frameworks que serão utilizados no projeto.
Spring WEB-MVC é uma abstração poderosa para a camada de apresentação, tornando muito flexível o uso de diferentes tipos de tecnologias no frnt-end da aplicação.
Veremos uma dessas abstrações que ajudam a modularizar e simplificar nosso trabalho do lado do servidor: Views.

Conceito de Views

Toda requisição que segue para o WEB-MVC passa pelo DispatcherServlet do spring. A partir daí, o container se responsabiliza por delegar a chamada para o controller correto, baseando-se nas configurações de sua aplicação.
Depois que a chamada é tratada pelo controller, o spring manda a resposta correspondente atrelada a uma View. Uma View é um descritor da forma com que os dados vão ser apresentados na interface, podendo ser JSP, JSF, JSon, XML, etc., ou até mesmo uma forma de encapsular os dados específica da sua aplicação.
O poder das Views está justamente no fato de ser apenas uma descrição de como os dados serão apresentados, portanto desconecta-se completamente da aplicação, e pode ser aproveitada em outras ocasiões por outros sistemas.
Uma View no Spring nada mais é do que uma interface Java que descreve o tipo do conteúdo, e é responsável por renderizar a requisição:

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

/*
* Copyright 2002-2008 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the “License”);
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an “AS IS” BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package org.springframework.web.servlet;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
* MVC View for a web interaction. Implementations are responsible for rendering
* content, and exposing the model. A single view exposes multiple model attributes.
*
*

This class and the MVC approach associated with it is discussed in Chapter 12 of
* Expert One-On-One J2EE Design and Development
* by Rod Johnson (Wrox, 2002).
*
*

View implementations may differ widely. An obvious implementation would be
* JSP-based. Other implementations might be XSLT-based, or use an HTML generation library.
* This interface is designed to avoid restricting the range of possible implementations.
*
*

Views should be beans. They are likely to be instantiated as beans by a ViewResolver.
* As this interface is stateless, view implementations should be thread-safe.
*
* @author Rod Johnson
* @author Arjen Poutsma
* @see org.springframework.web.servlet.view.AbstractView
* @see org.springframework.web.servlet.view.InternalResourceView
*/
public interface View

/**
* Name of the @link HttpServletRequest attribute that contains the response status code.
*

Note: This attribute is not required to be supported by all
* View implementations.
*/
String RESPONSE_STATUS_ATTRIBUTE = View.class.getName() + “.responseStatus”;

/**
* Return the content type of the view, if predetermined.
*

Can be used to check the content type upfront,
* before the actual rendering process.
* @return the content type String (optionally including a character set),
* or

null

if not predetermined.
*/
String getContentType();

/**
* Render the view given the specified model.
*

The first step will be preparing the request: In the JSP case,
* this would mean setting model objects as request attributes.
* The second step will be the actual rendering of the view,
* for example including the JSP via a RequestDispatcher.
* @param model Map with name Strings as keys and corresponding model
* objects as values (Map can also be

null

in case of empty model)
* @param request current HTTP request
* @param response HTTP response we are building
* @throws Exception if rendering failed
*/
void render(Map model, HttpServletRequest request, HttpServletResponse response) throws Exception;

}

Todo o código e JavaDoc está no projeto do Spring.

JSon e XML

Vamos criar um exemplo de controller com duas views diferentes: JSon e XML. JSon e Xml são os formatos mais comuns na Web, por isso vamos ver uma das maneiras de devolvê-las em nossos contrllers.
Não vou entrar no detalhe de como configurar os controllers da sua aplicação para funcionar com o Spring-WEB-MVC, pois não é o intuito deste post, e existe bastante documentação disponível na internet sobre o assunto.

A maneira que escolhi para o exemplo, foi deixar a resposta padrão da servlet como XML, e criar uma alternativa de view em JSon. Você pode configurar como quiser a ordem e o padrão de view da sua aplicação, essa escolha serve apenas para ilustar como lidar com os dois casos.
Comece criando alguma classe de domínio para servir de resposta do nosso controller:

1
2
3
4
5
6
7
8
9
10

public class Exemplo
private String nome;

public String getNome()
return nome;

public void setNome(String nome)
this.nome = nome;

}

Agora vamos criar um Controller para devolver nosso objeto de domínio:

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

@Controller
public class ExemploController

@RequestMapping(“/exemplo/xml”)
@ResponseBody
public Exemplo testando()
Exemplo ret = new Exemplo();
ret.setNome(“xml”);
return ret;

}

Agora temos uma servlet que responderá por “//exemplo/xml” devolvendo a instância de exemplo que acabamos de criar no método.
Vamos configurar agora nosso ‘empacotador’ de XML para torná-lo formato padrão da aplicação. No arquivo de beans do Spring crie os seguintes beans:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class=“org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter”>
name=“messageConverters”>
>
bean=“marshallingHttpMessageConverter” />
>
>
>

class=“org.springframework.oxm.xstream.XStreamMarshaller”
id=“xmlMarshaller”>
name=“aliases”>
>
key=“exemplo”>Exemplo
>
>
>
>

id=“marshallingHttpMessageConverter”
class=“org.springframework.http.converter.xml.MarshallingHttpMessageConverter”>
name=“marshaller” ref=“xmlMarshaller” />
name=“unmarshaller” ref=“xmlMarshaller” />
>

O que fizemos foi criar um “marshaller” de XML que usa o XStream para converter ‘de’ e ‘para’ XML. Também mapeamos nossa classe de domínio para o alias “exemplo”. Feito isso basta criar um bean que representa os conversores de mensagens do Spring, nesse caso ‘messageConverters’, e associar o conversor de XML nele.
Pronto! Agora que temos as configurações necessárias para criar XML, e anotamos nosso método do controller com ‘@ResponseBody’, o padrão do Spring será devolver o XML que representa a entidade de domínio criada:

1
2
3

>
>xml>
>

Para criar a view de JSon agora, vamos fazer de maneira diferente. Comece criando um bean em seu arquivo do Spring que representa a View de JSon:

1
2
3

id=“jsonview”
class=“org.springframework.web.servlet.view.json.MappingJacksonJsonView”>
>

Note que precisamos da dependência do ‘Jackson’ no classpath do nosso projeto, que está disponível no site do projeto ou até mesmo no repositório do maven.
Agora em nosso controler, vamos adicionar a dependência da view que acabamos de criar, e adicionar o método que tratará a requisição em JSon:

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

private View jsonview;

@Autowired
@Qualifier(“jsonview”)
public void setJsonview(View jsonview)
this.jsonview = jsonview;

@RequestMapping(“/exemplo/json”)
public ModelAndView testandoJson()
Exemplo ret = new Exemplo();
ret.setNome(“json”);
return new ModelAndView(this.jsonview, “response”, ret);

Repare que não precisamos da anotação ‘@ResponseBody’, e que ao invés de devolver um ‘Exemplo’ estamos devolvendo o ModelAndView do SpringWEBMVC.
Para que a resposta chegue no formato correto, basta mandar a view de JSon que criamos junto com o ModelAndView, e o objeto de domínio. Dessa forma temos a resposta que esperamos:

1
2
3
4

“response”:
“nome”:”json”

}

Conclusão

Para a moda REST que está tomando força nos últimos tempos, as múltiplas views do Spring é uma ótima ferramenta para fazer parte dessa onda, e ainda prover diferentes maneiras de seu servidor se comunicar com diversos tipos de dispositivos e aplicações clientes, sem comprometer código com regras de negócio.

Espero ter sido útil, e qualquer dúvida, crítica ou comentário são sempre bem vindos.

Por @Gust4v0_H4xx0r

Dez 6

JodaTime – Java Date que funciona!

Escrito por DClick Team em .NET, 1, 2.0, 4, 6, api, AR, bar, BI, blog, C#, camp, class, classe, classes, código, control, Curso, Cursos, Design, Design Pattern, Diversos, Documentação, efeito, err, exemplo, Exemplos, falha, for, Google, Hibernate, html, ide, IE, if, image, int, interface, internet, Java, lógica, map, mg, O, on, online, Opinião, padrão, pattern, print, problema, RIA, Ria’s Geral, S+S, Sem categoria, singleton, string, Sun, TAT, Tema, Teste, try, Twitter, UI, uint, Vários, XP, zend @ 12 6th, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários

Twitter!

JodaTime

Não existe segredo quando se fala da implementação de datas no Java: é ruim de usar. Alguns chegam a dizer que é errado usar inclusive, mas não serei tão extremo.
A API de datas do Java é ruim por vários motivos, como por exemplo, é mal documentada, não é Thread Safe, é difícil de manipular datas, e o comportamento nem sempre é o esperado.
Vamos ver como susbtituir a API de datas que vem Out of the Box no Java, por uma mais efetiva, amigável e confiável: JodaTime.

Lembrando do Calendar

Todo programador Java conhece o Calendar, e sabe que para usá-lo, basta seguir o Design Pattern singleton, ou seja, basta chamar o método de classe em Calendar que devolve a instância única do sistema para o Calendar.

Problema: não funciona.

Não funciona porque se a instância é singleton, e não utiliza threadlocking no código, então não é uma instância ThreadSafe. Logo toda vez que chamamos o getInstance() do Calendar, obtemos uma nova instância. Para ilustrar, crie um teste em JUnit 4 com o seguinte código:

1
2
3
4
5
6
7

Calendar calendar = Calendar.getInstance();

System.out.println(calendar.getTime());

Calendar calendar2 = Calendar.getInstance();

Assert.assertTrue(calendar == calendar2);

Rode o teste e veja a barra do JUnit ficar vermelha. O comparador ‘==’ usado em objetos, compara pelo endereço de memória, o que deveria ser o mesmo se fosse seguido o padrão singleton de verdade.
Pra piorar, todos os métodos que alteram as intâncias do Date estão expostos (por mais que estejam depreciados) para mantêr compatibilidade com versões anteriores da VM. Portanto o Date também não é ThreadSafe, pois não existe controle de concorrência em sua implementação.
Agora vamos deixar o Date e o Calendar de lado, e vamos ao JodaTime.

DateTime

O JodaTime diferencia muito bem os conceitos de data, instante de tempo, período, etc. A classe mais básica (interface no caso) é a ReadableInstant. Não precisa dizer que todas as modelagens de data implementam essa interface, permitindo comparar todos os tipos de modelagem de tempo pontuais. Um período não descreve um único instante ou ponto no tempo, por exemplo.
DateTime é talvez o ReadableInstant mais conhecido, e funciona muito parecido com o Date do Java.
Fatores que tornam o DateTime mais amigável são: é ThreadSafe pois é imutável, é muito bem documentado, e é muto fácil realizar operações com data. Vamos escrever um pouco de código para entender o que se passa.
Comece criando um DateTime. Como no Java, este DateTime criado possui o instante atual do sistema. Em seguida para efeito de teste (o teste pode falhar dependendo de quando for executado), adicione um dia na data criada, e verifique que o novo date aponta para amanhã:

1
2
3
4
5

DateTime date = new DateTime();

date = date.plusDays(1);

Assert.assertEquals(new DateTime().getDayOfYear() + 1, date.getDayOfYear());

Repare que tive que reassociar o date para que ele pudesse ser alterado, afinal DateTime é imutável, o mesmo comportamento que o BinInteger possui. Repare também que pra adicionar um dia, basta chamar plusDays. Este método já se encarrega de fazer toda a lógica de adicionar um dia na data, como por exemplo mudar o mês ou ano se for preciso, por isso se esse teste for rodado no dia 31 de dezembro, ele irá falhar pois o DateTime irá adicionar mais um dia a data, e perceberá que se trata do ano seguinte, e portanto getDayOfYear irá devolver ’1′, e não ’366′ ou ’365′ como esperado.
O JodaTime também trata anos bissestos e horário de verão se for selecionado o fuzo correto.
Existe uma API bem completa em DateTime para manipular todos os campos possíveis da data, sendo assim fica muito mais fácil iterar ao longo dos dias, sem precisar delegar pro Calendar a tarefa, e depois recuperar o resultado.
Não vou abordar muito da API do JodaTime, pois está muito bem documentada e existem muitos exemplos nas internet. O objetivo desse post é tratar do assunto do próximo tópico.

JodaTime e Hibernate

Pior que manipular datas, é persistir datas. Cada banco persiste data do seu próprio jeito, e cada implementação de ORM trata o Date do seu próprio jeito. Mas se você está utilizando o Hibernate, o JodaTime tem uma solução de padronização pra você: JodaTime Hibernate.
Com o JodaTime Hibernate é possível mapear diversos tipos de representação de data em suas classes Java, com ou sem TimeZone, como String ou bigint, como período ou duração, etc.
Para se ter uma idéia do que é possível, basta verificar a documentação online.
E para utiliza é muito fácil. Imagine que você tenha uma entidade com um campo DateTime, que se chama entryDate, portanto temos o getter:

1
2
3
4

@Column(nullable = false)
public DateTime getEntryDate()
return entryDate;

Para tornar este DateTime uma data que é padrão do banco que será utilizado, por exemplo, basta adicionar a seguinte anotação:

1
2
3
4
5

@Column(nullable = false)
@Type(type = “org.joda.time.contrib.hibernate.PersistentDateTime”)
public DateTime getEntryDate()
return entryDate;

Estamos falando para o hibernate utilzar o tipo de coluna descrito pelo PersistentDateTime, e utilizar o mesmo para converter a data novamente para DateTime quando for recuperado.
Caso você esteja fazendo engenharia reversa de algum banco, recomendo ler a descrição de todos os tipo disponíveis pra fazer a melhor escolha.
Com isso conseguimos obter todos os benefícios do JodaTime em nossas entidades, facilitando controlar as datas no domínio de nossas aplicações.

Espero ter despertado sua curiosidade com o JodaTime. Na minha opinião é uma das melhores bibliotecas Java disponíveis, mas não quero falar muito sobre suas funcionalidades, pois um dos pontos mais fortes da biblioteca é a facilidade de se acostumar com ela, e principalmente utilizar todos seus recursos. Quero que vocês tenham um pouco desse gostinho .

Por @Gust4v0_H4xx0r

Nov 16

LCCS e PHP com ZendAMF

Escrito por Leonardo França em .NET, 1, 2.0, 4, Adobe, AMF, amfphp, AR, Artigo, Artigos, C#, catch, class, classe, classes, developer, Documentação, exemplo, Exemplos, flash, Flex, Flex 4, for, framework, function, handle, image, int, Java, Javascript, live, LiveCycle, Mercado, mg, O, on, Password, PHP, player, portal, programação, pt, rest, RIA, Ria’s Geral, S+S, SDK, server, swf, Teste, try, UI, web, zend, zendAMF, zendFramework @ 11 16th, 2011 | via http://www.leonardofranca.com.br | Sem comentários

O Adobe LiveCycle Collaboration Service possui em seu SDK, exemplos de integração com as principais linguagens de programação web do mercado como PHP, Java, Python, etc.
Na documentação da Adobe, é recomendado o uso do AMFPHP ou o PHP puro mesmo, mas nada impede de usar tranquilamente em conjunto com o ZendFramework (usando ZendAMF)
Ryan Stewart escreveu dois artigos mostrando a implementação com PHP e REST.

Uma observação sobre o artigo de Ryan, no Flex 4, Adobe passou a usar o swfobject, então o modo de pegar os parâmetros via URL e passar para o SWF fica desse modo:

PLAIN TEXT

JAVASCRIPT:

var xiSwfUrlStr = “playerProductInstall.swf”;
var flashvars = ;
flashvars.roomURL = swfobject.getQueryParamValue(“roomURL”);
flashvars.authToken = swfobject.getQueryParamValue(“authToken”);
var params = ;

No SDK do LCCS, existe um arquivo chamado lccs.php, basta copiar para o mesmo diretório em que você já usa suas classes. Em seguida, adicionar o include no arquivo gateway.php

PLAIN TEXT

PHP:

require_once ‘Zend/Amf/Server.php’;
require_once ‘lccs.php’;
require_once ‘Test.php’;
/** Bootstrap */
// Instantiate server
$server = new Zend_Amf_Server();
$server->setProduction(false);
$server->setClass(‘Test’);
// Handle request
echo($server->handle());
?>

E está é uma simples classe para teste chamando o método que retorna o token para autenticação.

PLAIN TEXT

PHP:

class Test
private $account;
private $room;
private $devUsername;
private $devPassword;
private $secret;
//$accountURL = “https://collaboration.adobelivecycle.com/$account”;
private $accountURL;
private $roomURL;
function __construct()
//for LCCS
$this->account = “Your SDK account username from LCCS developer portal”;
$this->room = “The room you want to connect to”;
$this->devUsername = “Your LCCS developer account username”;
$this->devPassword = “Your LCCS developer account password”;
$this->secret = “The shared secret from the LCCS developer portal”;
//$accountURL = “https://collaboration.adobelivecycle.com/$account”;
$this->accountURL = “http://connectnow.acrobat.com/$this->account“;
$this->roomURL = “$this->accountURL/$this->room“;
public function getToken($data=array())
try
$this->account = new RTCAccount($this->accountURL);
$this->account->login($this->devUsername,$this->devPassword);
$session = $this->account->getSession($data['room']);
$displayName = $data['displayName'];
$username = $data['username'];
$role = $data['role'];
$token = $session->getAuthenticationToken($this->secret, $displayName, $username, $role);
return $token;
catch (Exception $e)
throw new Exception($e->getMessage());
}
}
?>

Nov 9

Conhecendo o LESS. The Dynamic Stylesheet.

Escrito por DClick Team em 1, 2.0, 4, 6, Adobe, Air, app, apple, AR, back, BI, browser, C#, class, classe, classes, código, css, css3, Curso, Cursos, custom, dados, demo, Desenvolvedor, Desenvolvimento, Desenvolvimento Web, Design, Destaque, Dica, Diversos, Documentação, dynamic, empresas, err, erro, error, Estilo, exemplo, Exemplos, for, function, gc, Google, html, html5, ide, IE, if, int, Java, Javascript, kit, layout, menu, Microsoft, MIX, NaN, O, on, Opinião, Outros, padrão, problema, problemas, programação, prova, pt, referencia, RIA, Ria’s Geral, RoR, S+S, Sem categoria, site, tag, TAT, Twitter, UI, uint, Utilidades, Ved, web, zend @ 11 9th, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários

Twitter!

Como todos devem ter percebido, nos últimos meses o CSS3 e o HTML5 tem ganho um grande destaque no desenvolvimento web. Grandes empresas como o Google, Microsoft, Adobe e Apple estão apoiando fortemente o desenvolvimento web utilizando WebStandards. Caso você já conheça algo sobre CSS, provavelmente deve saber como é complicado a organização desses documentos em um projeto de médio ou grande porte. Dado esses problemas conhecidos, foram surgindo os chamados pré-processadores de CSS, que viabilizam a criação de documentos de estilo, adicionando novas funcionalidades.

Hoje vamos conhecer o LESS, The Dynamic Stylesheet Language. O objetivo dessa biblioteca em javascript é prover uma série de funcionalidades para as, usualmente criadas a mão, folhas de estilos. Recursos tais como, variáveis, mixins (Multiple Inheritance, Traits), mixins parametrizáveis, funções, namespaces, importação, etc. Vamos aprender como utilizar os principais recursos dessa biblioteca em um projeto e como aproveitar o melhor dessa biblioteca para organizar corretamente nossas folhas de estilo.

Variables

As variáveis ajudam-nos a definir valores que podem ser utilizados em diversas regras do nosso CSS. Elas possuem escopo assim como em uma linguagem de programação orientada a objetos, trocando em miúdos:

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

// Arquivo stylesheet.less
// Essa variável foi definida no escopo do arquivo, logo, todas as regras do arquivo podem acessar seu valor.
@siteBackgroundColor: #FF3300; // Laranja

h1
// A variável headingColor foi criada no escopo da regra h1, logo, apenas ela e outras regras criadas dentro
// do mesmo escopo tem acesso ao seu valor.
@headingColor: #333333; // Cinza

// Isto significa que, se criarmos uma outra regra chamada &.mainTitle
// Observe o uso do &.classe, isso copia a regra pai e associa uma classe, o output disso seria exatamente h1.mainTitle
&.mainTitle
// Como essa regra esta contida na regra h1, podemos acessar o valor da variável headingColor.
color: @headingColor;

}

h2
// Se tentarmos acessar o valor nessa regra, que não encontra-se contida na regra h1, receberemos um erro da biblioteca
// informando que a variável headingColor não encontra-se definida.
color: @headingColor; // Brrrrrr! Error.

O que é interessante no uso de variáveis é a reutilização e organização. Imagine uma design guideline onde existem RGBs específicos a serem seguidos, essas cores poderiam ser definidas em um documento chamado color_variables.less e adicionados ao nosso arquivo principal utilizando a clausula @import.

@Import – Importando outros arquivos

Quando um arquivo LESS é importado, todas as suas variáveis e mixins são adicionados ao arquivo principal. Os escopos serão mantidos e a extensão .less é opcional.

@import “lib.less”
@import “lib”

É possível utilizar pastas nas clausulas de @import:

@import “where/is/my/stylesheet.less”
@import “where/is/my/stylesheet”

Mixins

No LESS, mixis são como uma espécie de classe CSS que pode ser reutilizada em diversas outras regras. Quando utilizadas, todas as propriedades definidas no mixin são adicionadas a regra onde a mesma foi adicionada, caso um mixin mude, todas as regras que o referenciam serão também modificadas.

Imagine o conceito de mixin como classes CSS orientadas a objeto, o que é interessante do mixin é que temos aqui algo como uma herança múltipla, caso uma mesma instrução seja declarada em mixins diferentes, e esses mixins adicionados a uma regra, o mixin declarado por último terá vantagem na construção final do CSS da regra onde foi adicionado.

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

.bordered
border-top: dotted 1px black;
border-bottom: solid 2px black;

// Declaramos agora uma regra qualquer que fará uso do nosso mixin.
div.someDiv
.bordered; // Simples assim, adicionamos todas as propriedades contidas no mixin em nossa regra.

div.anotherDiv
.bordered; // A mesmas propriedades serão adicionadas nessa regra.

Quando modificarmos o mixin .bordered, todos os elementos que o estão utilizando serão modificados. Reutilização!
Vamos para um exemplo mais usável para exemplificar como é um mixin parametrizável.

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

// Bordas arredondadas cross-browser.
// Observe que utilizamos algo parecido com uma função de javascript para declararmos nosso mixin.
// A notação de variável deve ser adicionada (@radius), com isso, criamos uma variável chamada “radius” no escopo
// do mixin que poderá ser utilizada apenas internamente pelo método.
// Observe também que declaramos um valor padrão para o parâmetro, de 5px.
.border-radius( @radius: 5px )

// Repare que utilizamos a mesma variável para todas as regras.
border-radius: @radius;
-moz-border-radius: @radius;
-webkit-border-radius: @radius;

// Para utilizarmos a regra, seguimos o mesmo padrão
div.someDiv
.border-radius; // Nesse caso estaremos utilizando o valor padrão de 5px.

div.anotherDiv
.border-radius(10px); // Nessa aplicação, modificamos o valor da propriedade para 10px.

É importante destacar que um mixin pode conter diversos parâmetros. Isso pode ser feito da seguinte forma:

1
2
3
4
5
6

// Declaramos um novo mixin
.border-radius-and-color( @radius: 5px, @borderColor: #000000 )

.border-radius( @radius ); // Observe que aqui reutilizei o mixin previamente definido. Composição de mixins.
border: 2px solid @borderColor; // Adicionamos agora a cor para a borda.

Nested Rules

Com o LESS você pode criar suas regras de CSS utilizando uma espécie de hierarquia. Vamos ver como isso funciona na prática.

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

// Dado o CSS abaixo
div#header #menu
…
rules

div#header #menu li a
…
more rules

div#header #topNav
…
another rules

Com o LESS, o mesmo CSS acima poderia ser escrito da seguinte forma:

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

// Como utilizar hierarquia com Less
div#header
#menu
ul
li

}
}

#topNav

}

Depois de processado, o CSS será exatamente igual. Você não precisa utilizar esse esquema de hierarquia caso não queira, é importante lembrar que o LESS é apenas uma extensão do CSS, se for de desejo do desenvolvedor, podemos escrever um código LESS sem usar nenhum recurso especial, como se fosse um CSS tradicional.

Operations

Com o LESS o seu CSS sabe fazer contas. Qualquer número, cor ou variável pode ser utilizada em uma operação aritmética.
Ele sabe identificar quando estamos utilizando uma cor ou um número, por exemplo:

1
2
3
4
5
6
7

@base: 5%;
@filler: @base * 2;
@other: @base + @filler;

color: #888 / 4;
background-color: @base-color + #111;
height: 100% / 2 + @filler;

Assim como no javascript, é possível também utilizar parênteses nas suas operações:

1	width: (@var + 5) * 2;

Color Functions

Na minha opinião um dos recursos mais úteis durante o desenvolvimento de uma aplicação. Podemos efetuar operações em cima de RGBs, por exemplo, imagine que o layout do seu website foi criado baseado-se em apenas uma cor, utilizando diversos tons dessa cor. Com o LESS é possível utilizar métodos pré-definidos como lighten, saturate, darken, fadein, fadeout e spin. Esses métodos retornam sempre um RGB que pode ser utilizado em seu LESS. Vejamos alguns exemplos:

1
2
3
4
5
6
7
8
9

@base: #f04615;

.class
// Saturo em 5% a cor base.
color: saturate(@base, 5%);

// Utilizo a cor base 25% mais clara
background-color: lighten(@base, 25%);

É possível também extrair informações de uma determinada cor para ser utilizada em outra.
Isso é feito a partir dos métodos hue, saturation e lightness.

1
2
3

hue(@color); // retorna o valor do canal ‘hue’ da cor @color
saturation(@color); // retorna o valor do canal ‘saturation’ da cor @color
lightness(@color); // retorna o valor do canal ‘lightness’ da cor @color

Namespaces

Em dado momento necessitamos organizar uma série de mixins e variáveis. Para isto podemos utilizar um conceito presente no LESS chamado Namespaces. Assim como em linguagens de programação orientadas a objetos, que possuem o conceito de pacotes, os namespaces fornecem encapsulação para nossas folhas de estilo. Isso pode ser implementado facilmente utilizando a mesma notação de ID do CSS tradicional. Vejamos.

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

#bundle

.button ()

display: block;
border: 1px solid black;
background-color: grey;
&:hover background-color: white
}
.tab …
.citation …
}

Verifique que acima, criamos um mixin chamado button dentro do namespace bundle. Para o utilizarmos devemos fazer da seguinte forma:

1
2
3
4

#header a
color: orange;
#bundle > .button; // Estamos acessando o namespace ‘bundle’ e fazendo uma chamada para o mixin ‘button’.

Uma utilização muito comum dos namespaces é na criação de pequenas bibliotecas de utilidades. Imagine que sua empresa pode possuir uma série de arquivos LESS, e em um determinado projeto você necessita de acesso a esses mixins, variáveis, etc. Organizar seus documentos com namespaces fácilita a visualização e localização de uma determinada instrução no seu documento LESS, como por exemplo, um mixin customizado que pode ser facilmente encontrado a partir da sua indicação de namespace.

1
2
3

someRule
#dclick > .border-radius(10px);

Conclusão

Como podemos ver, o LESS facilita uma série de tarefas que são praticamente impossíveis de serem efetuadas pelo CSS tradicional.
Aconselho a todos que tenham interesse em se aprofundar mais na biblioteca a conhecer o website (http://lesscss.org/). Lá você poderá encontrar a documentação com maior riqueza de informações também poderá ver alguns exemplos de código que não foram abordados nesse post.

Qualquer dúvida, sinta-se a vontade e envie-nos um comentário!
Abraço!

Nov 8

Spring 3.1 RC1 – Cache Abstraction

Escrito por DClick Team em 1, 2.0, 4, 6, action, app, AR, Arquitetura, Banco de Dados, BI, blog, C#, cache, class, classe, configuração, dados, Documentação, Download, err, erro, exemplo, for, framework, Google, html, ide, IE, if, int, interface, Java, lite, map, mapa, O, on, Outros, padrão, pt, reference, RIA, Ria’s Geral, S+S, Sem categoria, site, Spring, Spring Framework, SpringFramework, string, Sun, tag, TAT, Teste, Twitter, UI, uint, XML, zend @ 11 8th, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários

Twitter!

Spring Cache Abstraction

Abordamos um das novas funcionalidades do Spring 3.1 RC1, profiles e environments. Ainda existem outras funcionalidades, mas hoje iremos dar uma olhada em Cache Abstraction.

Cache Abstraction é literalmente uma abstração out of the box para adicionar uma camada de cache sobre seus beans, usando uma arquitetura AOP para gerenciar o que deve e o que não deve ser feito o cache.
Usar a nova camada de cache é muito fácil se você já está habituado com Spring, e veremos uma das diferentes maneiras de configurar seus beans.

Baixando a Denpendência

Para quem utiliza maven, basta adicionar a seguinte dependência no pom do seu projeto:

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

>
>
>org.springframework.maven.milestone>
>Spring Maven Milestone Repository>
>http://maven.springframework.org/milestone>
>
>

>
>
>org.springframework>
>spring-core>
>3.1.0.RC1>
>
>
>org.springframework>
>spring-context>
>3.1.0.RC1>
>
>

Se você perferir, pode baixar os jar direto do site do spring.
Sem segredos aqui, basta adicionar as dependências ao projeto e está pronto para usar.

Entendendo o funcionamento

A maneira com que o cache funciona é bem simples. Você pode enxergar o cache como um mapa chave-valor, onde a chave é o conjunto de argumentos do seu método, e o valor é o valor devolvido pelo seu método. Pensando assim fica fácil entender o funcionamento que irei mostrar no exemplo.
Referente a configuração do Spring, é necessário instanciar um gerenciador de cache, ou na linguagem spring, cacheManager. Existe algumas implementações de cache manager disponível no spring, portanto iremos utilizar uma delas em nosso exemplo.
Vamos escrever um teste unitário com JUnit 4.8.1 para ilustrar o comportamento do cache.
Comece criando um arquivo padrão de beans do spring, mas com um namespace a mais:

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

>
Repare que estamos utilizando o namespace de cache além dos usuais.
A única configuração que iremos fazer aqui, é a do cache manager. Crie um bean da classe >SimpleCacheManager> e adicione o seguinte bean como cache gerenciado:
>
cc lang=”XML”
public interface CacheableTest

@CacheEvict(value = “property”, allEntries = true)
void evictCache();

@Cacheable(“property”)
String getForCache(String s);

String getProperty();

void setProperty(String property);

Repare no getter e setter que usaremos no teste, e na anotação @Cacheable(“property”). Esta anotação está dizendo que o valor que este método devolver será armazenado no cache que configuramos previamente como property. Fato importante é que este valor é referente ao argumento passado como parâmetro no método.
A outra anotação @CacheEvict(value = “property”, allEntries = true) descreve o método que chamaremos para esvaziar o cache. Note que passamos o nome do cache, e que ele deve limpar todos os valores.
É importante notar também que pode ser passado mais de um nome de cache em ambas as anotações.
Uma implementação básica para nosso bean pode ser:

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

@Component(“cacheBean”)
public class CacheableBean implements CacheableTest

private String property;

public String getForCache(String s)
return this.property;

public String getProperty()
return property;

public void setProperty(String property)
this.property = property;

public void evictCache()
// Não faz nada

}

Estou usando o package scan para instanciar o bean. Agora nosso teste:

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

public class CacheTest

@Test
public void testCache()

ApplicationContext ctx = new ClassPathXmlApplicationContext(
“spring31-test-beans.xml”);

CacheableTest bean = ctx.getBean(“cacheBean”, CacheableTest.class);

bean.setProperty(“teste”);

Assert.assertEquals(“teste”, bean.getProperty());
Assert.assertEquals(“teste”, bean.getForCache(“a”));

bean.setProperty(“teste2″);
Assert.assertEquals(“teste2″, bean.getProperty());
Assert.assertEquals(“teste”, bean.getForCache(“a”));
Assert.assertEquals(“teste2″, bean.getForCache(“b”));

bean.setProperty(“teste3″);
Assert.assertEquals(“teste3″, bean.getProperty());
Assert.assertEquals(“teste”, bean.getForCache(“a”));
Assert.assertEquals(“teste2″, bean.getForCache(“b”));

bean.evictCache();
bean.setProperty(“teste4″);
Assert.assertEquals(“teste4″, bean.getProperty());
Assert.assertEquals(“teste4″, bean.getForCache(“a”));
Assert.assertEquals(“teste4″, bean.getForCache(“b”));

}

O arquivo de beans se chama spring31-test-beans.xml.
Repare que estamos invocando o método getForCache passando alguns valores diferentes, e o valor devolvido é sempre igual, mesmo que depois setamos um valor diferente ao bean. Para atualizar o valor e limpar o cache, basta invocar o método evictCache que havíamos anotado com @CacheEvict.
Vale a pena brincar um pouco com o funcionamento do cache, e até mesmo criar outros caches e ver o comportamento do evict em diferentes métodos.

Últimas Considerações

As mesmas configurações que fizemos com anotações, pode-se fazer direto no XML. Não entrarei no detalhe pois o funcionamento é exatamente o mesmo, mas se você preferir basta olhar a documentação que é bem straightforward.
Lembre-se que esta camada de cache não possui nenhuma relação com o banco de dados, e deve ser usada com muito cuidado em tais casos, pois alguns erros de concistência podem aparecer devido a um cache desatualizado.
Vale a pena brincar com o cache manager, pois o spring suporta o uso do EhCache, o que pode ser muito útil se você já possui alguma configuração pré-definida para sua aplicação.

Por enquanto é isso, qualquer dúvida mande nos comentários que responderei assim que possível.

Por @Gust4v0_H4xx0r

Out 30

Windows Phone Mango – Local Database

Escrito por Alexandre Tadashi em .NET, 1, 2.0, 4, 6, abas, AMF, Aplicativos, app, AR, Arquitetura, arte, Artigo, auto, BI, blog, Blogs, botão, C#, camp, class, classe, classes, cliente, código, collection, cultura, Curso, Cursos, dados, demo, desempenho, Desenvolvedor, Design, designer, Documentação, dotnet, DRE, err, event, Evento, exemplo, Ferramenta, for, Formação, handle, html, ide, IE, if, int, interface, layout, library, Links, linq, Linq to Sql, map, mg, Microsoft, monitor, MSDN, mudanças, O, on, Otimização, Outros, Partilha, processo, pt, rest, RIA, Ria’s Geral, S+S, SDK, server, serviço, silverlight, SQL Server, state, string, TAT, Tecnologia, Tema, template, Treinamento, UI, UX, Ved, vs, window, windows, XAML @ 10 30th, 2011 | via http://alexandretadashi.net/ | Sem comentários

Na versão Mango do Windows Phone, você pode manipular uma base de dados localmente, chamada de local database na documentação oficial, o recurso permite que o desenvolvedor crie aplicativos com registros de dados em tabelas, além de manipular seus registros utilizando o LINQ to SQL.

Uma base de dados local no WP7 fica localizada no Isolated Storage, um local acessível somente pela aplicação corrente, a arquitetura fica conforme a figura abaixo, onde temos a aplicação que contém um DataContext e através de LINQ to SQL, fazemos o acesso a base de dados local no Isolated Storage

Arquitetura Local Database

Para saber mais sobre Isolated Storage acessem os links:

http://msdn.microsoft.com/en-us/library/ff402541(v=vs.92).aspx

http://www.windowsphonebrasil.net/windowsphonebrasil/post/2010/10/08/Salvando-e-restaurando-o-Application-State-no-Windows-Phone-7.aspx

No WP7 as aplicações ficam eram áreas isoladas uma das outras, ou seja, uma aplicação não tem acesso ao Isolated Storage de outra aplicação, portanto até o momento não é possível compartilhar uma base de dados local com diversas aplicações. Diferente de uma base de dados SQL Server, um local database não pode rodar como um serviço continuo, visto que ele é executado somente durante o processo da aplicação.

Você pode criar um local database para manipular uma quantidade de dados razoável utilizando as facilidades de consultas do LINQ to SQL juntamente com o relacionamento de tabelas, similar a uma base de dados comum, o local database é uma implementação do SQL CE para o WP7, permitindo realizar facilmente tarefas com incluir, alterar , excluir e realizar consultas com LINQ.

Até o momento não existe uma ferramenta de designer visual e oficial para criar as tabelas, relacionamentos, etc, com a base de dados local, o que poderia facilitar muito, neste artigo faremos um exemplo simples, somente com uma tabela, porém, em um projeto mais complexo, essa tarefa poderia ser um pouco trabalhosa, uma forma não oficial de criar o modelo seria utilizar o SQL Metal, para mais informação, acessem o Centro de Treinamento Oficial do Windows Phone no MSDN ou através do link : http://windowsphonegeek.com/articles/Using-SqlMetal-to-generate-Windows-Phone-Mango-Local-Database-classes .

Com o SQL Metal podemos criar o Data Context através de um comando e com poucas modificações deixá-lo compatível com o Mango e poupar a codificação manual da criação de tabelas e relacionamentos.

Exemplo de comando do SQL Metal:

%ProgramFiles(x86)%Microsoft SDKsWindowsv7.0ABin>SqlMetal.exe
/code:”C:CaminhoClienteDC.cs” “C:CaminhoClienteDB.sdf”

Outras formas:

http://claudiufarcas.blogspot.com/2011/10/windows-phone-mango-sql-ce-tips-and.html

http://blogs.ugidotnet.org/corrado/archive/2011/06/05/using-local-database-in-wp7-mango.aspx

Nesta primeira parte do artigo vou criar uma base de dados muito simples, com uma tabela somente e um único campo, dessa forma podemos focar em como criar e entender os conceitos envolvidos Vou criar uma base de dados Cliente.sdf, com uma tabela chamada Cliente e um campo chamado Nome.

A primeira classe que vamos criar é a entidade Cliente e decorar com alguns atributos utilizados para a manipulação da base de dados, a classe servirá de apoio para a criação da tabela cliente. Para que você possa inserir os atributos nas propriedades da classe, é necessário adicionar o using System.Data.Linq.Mapping, em seguida adicione o atributo [Table] logo acima da criação da classe e adicione o atributo [Column()] em cada propriedade, na primary key da tabela, personalize com :

[Column(IsPrimaryKey = true, IsDbGenerated = true, DbType = "INT NOT NULL Identity", CanBeNull = false, AutoSync = AutoSync.OnInsert)]

Dessa forma a coluna será criada na tabela como sendo Primary Key, não permitindo registros duplicados e gerando automaticamente um número a cada inclusão. Com a adição do atributo Column() nas outras propriedades, cada coluna correspondente será criado na tabela.

Com os atributos de colunas você pode definir uma série de recursos, para saber quais são os atributos de colunas que você pode utilizar no LINQ to SQL para WP7 acesse o link http://msdn.microsoft.com/en-us/library/system.data.linq.mapping.columnattribute(VS.95).aspx

Um atributo em especial que adiciona uma coluna de versão pode auxiliar no desempenho de grandes atualizações de dados, apresentando uma significativa melhoria na aplicação, é o IsVersion=true, essa otimização é exclusiva para o LINQ to SQL do WP7 e usado internamente para identificar a versão da coluna modificada:

[Column (IsVersion = true)]
_VERSION Binary privado;

Igualmente importantes são os atributos de associações, que permitem realizar o relacionamento entre as tabelas, para mais informações acesse:

http://msdn.microsoft.com/en-us/library/system.data.linq.mapping.associationattribute(v=VS.95).aspx

Exemplo de Associação:

[Association(Storage = "_cliente", ThisKey = "_clienteId", OtherKey = "Id", IsForeignKey = true)]

Código da Classe Cliente:

? ? ?  [Table]

? ? ?  public class Cliente : INotifyPropertyChanged, INotifyPropertyChanging

? ? ?

? ? ? ? ? ? ?  #region INotifyPropertyChanged Members

? ? ? ? ? ? ?  public event PropertyChangedEventHandler PropertyChanged;

? ? ? ? ? ? ?  private void NotifyPropertyChanged(string propertyName)

? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ?  if (PropertyChanged != null)

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ?  }

? ? ? ? ? ? ?  #endregion

? ? ? ? ? ? ?  #region INotifyPropertyChanging Members

? ? ? ? ? ? ?  public event PropertyChangingEventHandler PropertyChanging;

? ? ? ? ? ? ?

? ? ? ? ? ? ?  private void NotifyPropertyChanging(string propertyName)

? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ?  if (PropertyChanging != null)

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  PropertyChanging(this, new PropertyChangingEventArgs(propertyName));

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ?  }

? ? ? ? ? ? ?  #endregion

? ? ? ? ? ? ?  [Column(IsPrimaryKey = true, IsDbGenerated = true, DbType = "INT NOT NULL Identity", CanBeNull = false, AutoSync = AutoSync.OnInsert)]

? ? ? ? ? ? ?  private string id;

? ? ? ? ? ? ?  public string Id

? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ?  get

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  return id;

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ?  set

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  if (id != value)

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  NotifyPropertyChanging("Id");

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  id = value;

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  NotifyPropertyChanged("Id");

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ?  }

? ? ? ? ? ? ?  }

? ? ? ? ? ? ?

? ? ? ? ? ? ?  [Column()]

? ? ? ? ? ? ?  private string nome;

? ? ? ? ? ? ?  public string Nome

? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ?  get

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ?  ? ? ? ? ? ? ? ? return nome;

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ?  set

? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  if (nome != value)

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  NotifyPropertyChanging("Nome");

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  nome = value;

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  NotifyPropertyChanged("Nome");

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ? ?  }

? ? ? ? ? ? ?  }

? ? ? ? ? ? ?

? ? ?  }

Em aplicações Silverlight é comum implementar a interface INotifyPropertyChanged para monitorar mudanças nas propriedades da classe , e tirar um melhor proveito do recursos de databinding da tecnologia, para auxiliar o LINQ to SQL, também vamos implementar a interface INotifyPropertyChanging, com ela é possível monitorar quando uma propriedade será modificada e com isso o DataContext é informado e pode identificar as mudanças e melhorar a performance da aplicação.

O Data Context é o local onde definimos o contexto dos dados que servirão para criar a base de dados local, o LINQ to SQL depende do mapeamento entre o modelo de objetos e o esquema da base de dados. Dependendo da complexidade do modelo, esse arquivo pode ser trabalhoso de ser criado manualmente, mas existem formas de utilizar alguma ferramenta para cria-lo, o SQL Metal é uma delas conforme comentado acima no artigo.

Crie uma classe chamada ClienteDataContext , ela vai herdar de DataContext, o DataContext contém diversas propriedades e métodos que auxiliam na manipulação de base de dados, como por exemplo, verificar se uma base de dados existe, criar e excluir uma base de dados, entre outros, mais adiante vamos utilizar o método CreateDatabase() para criar fisicamente a base de dados local no Windows Phone.

A próxima etapa é criar a string de conexão com a base de dados, utilizaremos a palavra chave “isostore” para informar que o arquivo ficará no Isolated Storage, após isso informaremos o nome da base de dados como Cliente.sdf. É na string de conexão que você pode inserir um senha de acesso a base de dados, informar uma cultura específica ou até mesmo criar uma base de dados somente leitura, para mais informações sobre string de conexões para o WP7 acesse http://msdn.microsoft.com/en-us/library/hh202861(v=vs.92).aspx

Por último vamos definir uma tabela Cliente de acesso público e única no DataContext através de public Table Cliente.

No App.xaml.cs da aplicação , localize o construtor da classe e no final adicione o código abaixo, neste momento vamos criar uma base de dados usando o DataContext criado anteriormente, o código verifica se existe uma base de dados e caso não exista ele já cria uma nova base de dados.

using (ClienteDataContext ctx = new ClienteDataContext(ClienteDataContext.DBConnectionString))

? ? ?  if (ctx.DatabaseExists() == false)

? ? ? ? ? ? ?

? ? ? ? ? ? ? ? ? ?  ctx.CreateDatabase();

? ? ? ? ? ? ?

Para finalizar o artigo vou criar uma tela simples em Silverlight, sem se preocupar com o layout, a tela tem um botão chamado “add” que vai adicionar um registro na base de dados e logo abaixo um ListBox chamado “lst”, que está ligado através de databinding a propriedade ItemSource com uma ObservableCollection chamada Items, na propriedade Text vamos mostrar o nome do cliente também ligando através de databinding.


? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  ? Grid.Row="1" Margin="12,0,12,0">
? ? ? ? ? ? ? ? ? ? ?  ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? 
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? 

No constructor do MainPage vamos criar uma instância do DataContext chamado clienteDB :
clienteDB = new ClienteDataContext(ClienteDataContext.DBConnectionString);
No evento ? Loaded da MainPage, realizamos um consulta LINQ to SQL e já adicionamos o resultado em uma ObservableCollections chamada Items, que está ligado ao ItemSource da ListBox, veja como é prático ligar as informações na tela, neste exemplo como o foco é o conceito de local database, o projeto foi criado todo no code-behind da MainPage, mas você poderia criar usando o ViewModel e ligando o ObservableCollection com a View.
var result = from Cliente r in clienteDB.Cliente
select r;
Items = new ObservableCollection(result);
Para mais informações sobre LINQ:
http://msdn.microsoft.com/en-us/library/bb397897.aspx
http://msdn.microsoft.com/en-us/library/bb386976.aspx
http://msdn.microsoft.com/en-us/library/bb386913.aspx
Vamos agora para o código do botão “add” que vai adicionar os registros na base de dados, através do InsertOnSubmit() adicionamos o objeto ao DataContext e através do SubmitChanges(), o objeto é registrado na base de dados, por último, inserimos o objeto na coleção para que seja apresentado na tela.
Cliente c = new Cliente();
c.Nome = txtNome.Text;
clienteDB.Cliente.InsertOnSubmit(c);
clienteDB.SubmitChanges();
Items.Add(c);
? 
Código completo da MainPage:
? ?  public partial class MainPage : PhoneApplicationPage, INotifyPropertyChanged
? ? ?  
? ? ? ? ? ? ? ?  ClienteDataContext clienteDB;
? ? ? ? ? ? ? ?  #region INotifyPropertyChanged Members
? ? ? ? ? ? ? ?  public event PropertyChangedEventHandler PropertyChanged;
? ? ? ? ? ? ? ?  private void NotifyPropertyChanged(string propertyName)
? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  if (PropertyChanged != null)
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ?  }
? ? ? ? ? ? ? ?  #endregion
? ? ? 
? ? ? ? ? ? ?  private ObservableCollection _items;
? ? ? ? ? ? ?  public ObservableCollection Items
? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  get
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  return _items;
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  set
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  if (_items != value)
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  _items = value;
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  NotifyPropertyChanged("Items");
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  }
? ? ? ? ? ? ?  }
? ? ? ? ? ? ? 
? ? ? ? ? ? ?  // Constructor
? ? ? ? ? ? ?  public MainPage()
? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  InitializeComponent();
? ? ? ? ? ? ? ? ? ? ?  clienteDB = new ClienteDataContext(ClienteDataContext.DBConnectionString);
? ? ? ? ? ? ? ? ? ? ?  this.DataContext = this;
? ? ? ? ? ? ? ? ? ? ?  Loaded += new RoutedEventHandler(MainPage_Loaded);
? ? ? ? ? ? ?  
? ? ? ? ? ? ?  void MainPage_Loaded(object sender, RoutedEventArgs e)
? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  var result = from Cliente r in clienteDB.Cliente
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  select r;
? ? ? ? ? ? ? ? ? ? ?  Items = new ObservableCollection(result);
? ? ? ? ? ? ?  
? ? ? ? ? ? ?  private void add_Click(object sender, RoutedEventArgs e)
? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  Cliente c = new Cliente();
? ? ? ? ? ? ? ? ? ? ?  c.Nome = txtNome.Text;
? ? ? ? ? ? ? ? ? ? ?  clienteDB.Cliente.InsertOnSubmit(c);
? ? ? ? ? ? ? ? ? ? ?  clienteDB.SubmitChanges();
? ? ? ? ? ? ? ? ? ? ?  Items.Add(c);
? ? ? ? ? ? ?  
? ? ?  }
Links:
Boas Práticas:
http://msdn.microsoft.com/en-us/library/hh286406(v=vs.92).aspx
Mais informações sobre local database no Windows Phone :
http://msdn.microsoft.com/en-us/library/hh202860(v=vs.92).aspx
http://msdn.microsoft.com/en-us/library/hh202876(v=VS.92).aspx
Alterações do esquema da base de dados:
http://msdn.microsoft.com/en-us/library/hh394018(v=VS.92).aspx

Out 10

Criando extensão para o Google Chrome – Parte 1/2

Escrito por Gabriel Versallini em 1, 2.0, 3.5, 4, 6, action, AR, Artigo, back, botão, browser, C#, chrome, class, Curso, developer, Documentação, exemplo, for, Google, html, ide, IE, if, image, Java, Javascript, Mac, mg, O, on, Pessoal, procura, pt, RIA, Ria’s Geral, S+S, screen, site, super(), tool, UI, window, windows @ 10 10th, 2011 | via http://www.versallini.com.br | Sem comentários

Olá, pessoal!

No artigo de hoje mostraremos como é simples criar uma extensão para ao Google Chrome. Apesar de ser um recurso esquecido pelas agências, pode agregar muito valor ao seu negócio.

É importante que tenha um bom conhecimento de HTML e JavaScript. Abra o editor de sua preferência e vamos ao trabalho! (Na época de Windows gostava do Notepad++, no Mac ainda não tenho preferência.)

Documentação Oficial: http://code.google.com/chrome/extensions/devguide.html

Primeiro devemos criar uma pasta com nome da extensão, VERSALLINI. Em seguida, precisamos criar o arquivo manifest.json, pois é ele que o Chrome procura na hora de identificar e instalar a extensão. Veja a seguir:


  "name": "VERSALLINI",
  "version": "1.0",
  "description": "Gabriel Versallini ,
  "permissions": [
    "http://www.versallini.com.br/"
  ]
}

Salve a imagem abaixo na pasta da extensão com o nome de icon.png:

Para saber se fez tudo certinho abra o Google Chrome clique em Tools/Extensions, em seguida no botão Developer Mode no canto superior direito e logo depois em Load unpacked extension…. Selecione a pasta da extensão e pronto, nossa extensão será instalada com sucesso, veja a seguir:

Repare que mesmo com a extensão instalada ainda não criamos nenhuma funcionalidade para ela. Daremos continuidade no próximo artigo, é importante resaltar que daqui pra frente é como criar um site porém com tamanho reduzido.

Divirta-se!
Abraço

Ago 9

Spring Security Flex e Java

Escrito por Felipe Borella em 1, 2.0, 4, Adobe, AR, BI, blog, C#, Dica, Documentação, facebook, Flex, Flexmania, IE, int, Java, Mate, O, on, PHP, rest, RIA, Ria’s Geral, S+S, Spring, string, TAT, UI, XP @ 08 9th, 2011 | via http://www.fborella.com.br/blog/ | Sem comentários

Ae pessoas. Blz?

Só estou passando aqui para indicar um material que vale muito a pena para quem integra Java e Flex usando Spring é do FlexMania do Fabiel Prestes.

Segue o link

Só uma pequena dica quanto as annotations isso aqui tambem funciona

@Secured ("ROLE_USER", "ROLE_ADMIN")
public void save(Contact contact);

Pode passar um array de String (by documentação do Spring Security )

Felipe

Share on Facebook

Jun 27

Metadata Tags customizadas com Code completion

Escrito por Willian Mano em 1, 2.0, 2009, 3d, 4, 6, Adobe, AR, Artigo, as3, BI, blog, C#, class, código, configuração, custom, Documentação, event, exemplo, flash, flash builder, Flex, Flex 3, Flex 4, fonte, for, Formação, framework, Frameworks, handle, html, int, Links, mg, O, on, Pessoal, Plugin, Projetos, pt, RIA, Ria’s Geral, S+S, SDK, string, Sun, Swiz Framework, tag, TAT, Twitter, UI, XML @ 06 27th, 2011 | via http://blog.willianmano.eti.br/ | Sem comentários

Olá pessoal, nesse breve artigo eu irei falar um pouco sobre as Metadata Tags.

[Importante]
A partir da versão 4.5 do flex as Metadatas customizadas não precisam ser declaradas para o compilador nos projetos Flex, o conhecido “-keep-as3-metadata”, quem trabalha com Frameworks de terceiros entende bastante isso.

Notei na nova versão do Swiz Framework que existe também uma complementação do código para metadatas personalizadas como “Inject e EventHandler”. Depois de vasculhar os fontes do Swiz Framework encontrei o arquivo metadata.xml que é o responsável pela declaração de todas essas metadatas.

Se você está criando uma biblioteca que possui suas próprias metadatas e deseja criar uma complementação do código, basta seguir os passos da documentação da própria Adobe, é bem simples.

Esse é um exemplo desse arquivo de configuração.

Você pode se basear pelo arquivo do próprio framework do flex. Fica na pasta: sdks4.5.0frameworksmetadata.xml

Espero que a informação tenha sido útil.

Abaixo seguem alguns links interessantes relacionados ao assunto.