Aprendendo a Programar

Captulo VII
O servidor web. Conceitos avanados
 Validao
O que a validao? Imaginemos que vocs tm um site na
web, onde as pessoas se cadastram. Ou seja, criam seu
usurio. Isso feito todos os dias, para obter uma conta de
correio eletrnico, ou ativar uma rede social.
Nessa tela de cadastramento, precisam completar muitas
informaes; por exemplo, nome, sobrenome, data de
nascimento, telefone, endereo, pas, cidade, endereo de
correio eletrnico, etc. Cada um desses dados tem alguma
classe ou tipo. O que significa isso? A data de nascimento
tem a forma de uma data. O nome e o sobrenome so
palavras. O correio eletrnico tem o smbolo @ e um . ,
o nmero telefnico tem nmeros y, em alguns casos, -
ou parnteses.
 Validao
Mas, o que acontece na realidade? Como o espao para
inserir dados nem sempre est programado corretamente,
o usurio poderia inserir dados de natureza errada em
nossa interface e, portanto, teramos informaes
incorretas, ou dados sujos. Assim, o usurio poderia dizer
que seu correio eletrnico , por exemplo, Joo da
Silva@ola. Ou que sua data de nascimento
milnovecentos.
Por esse motivo, feita o que chamamos validao de
dados. Isso , basicamente, corroborar que os dados
tenham o tipo e a forma adequados. Isso no significa que
o usurio no possa mentir, mas, no mnimo, garantimos
que os dados cumpram determinadas regras.
 Validao no servidor
A validao pode ser feita enviando as informaes para o
servidor, para que ele as analise e, depois, o aplicativo
decida se elas tm o formato correto e as aprove, ou se
sero exibidas mensagens na interface com os erros
encontrados.
Podemos fazer isso utilizando novamente a estrutura de
meu modelo MVC, cuja viso requeira ao usurio inserir
informaes, para que, logo, o controlador envie essas
informaes para o modelo. Assim, o modelo decidir
como se atualizar a viso, levando em conta se os dados
inseridos so corretos ou no.
Como exemplo, vamos mostrar quais seriam os
componentes MVC para inserir um novo dado Pessoa, e
outra interface para poder consultar os dados.
 Validao no servidor - Modelo
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace MvcSimpleModelBinding.Models
{
public class Person
{
public int Id { get; set; }
public string Name { get; set; }
public int Age { get; set; }
public string Street { get; set; }
public string City { get; set; }
public string State { get; set; }
public int Zipcode { get; set; }
}
}
Validao no servidor - Controlador
public class PersonController : Controller
{
static List<Person> people = new List<Person>();
public ActionResult Index()
{
return View(people);
}
public ActionResult Details(Person person)
{
return View(person);
}
public ActionResult Create()
{
return View();
}
[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Create(Person person)
{
if (!ModelState.IsValid)
{
return View("Create", person);
}
people.Add(person);
return RedirectToAction("Index");
}
}
 Validao no servidor - Viso Index
<h2>Index</h2>
<table>
<tr>
<th></th>
<th>
Id
</th>
<th>
Name
</th>
</tr>
<% foreach (var person in Model) { %>
<tr>
<td><%= Html.ActionLink("Details", "Details", person )%></td>
<td><%= Html.Encode(person.Id) %></td>
<td><%= Html.Encode(person.Name) %></td>
</tr>
<% } %>
</table>
<p>
<%= Html.ActionLink("Create New", "Create") %>
</p>
 Validao no servidor - Viso Create
<h2>Create</h2>
<%= Html.ValidationSummary("Create was unsuccessful. Please correct the errors and try again.") %>
<% using (Html.BeginForm()) {%>
<fieldset><legend>Fields</legend>
<p>
<label for="Id">Id:</label><%= Html.TextBox("Id") %><%= Html.ValidationMessage("Id", "*") %>
</p>
<p>
<label for="Name">Name:</label><%= Html.TextBox("Name") %><%= Html.ValidationMessage("Name", "*") %>
</p>
<p>
<label for="Age">Age:</label><%= Html.TextBox("Age") %><%= Html.ValidationMessage("Age", "*") %>
</p>
<p>
<label for="Street">Street:</label><%= Html.TextBox("Street") %><%= Html.ValidationMessage("Street", "*") %>
</p>
<p>
<label for="City">City:</label><%= Html.TextBox("City") %><%= Html.ValidationMessage("City", "*") %>
</p>
<p>
<label for="State">State:</label><%= Html.TextBox("State") %><%= Html.ValidationMessage("State", "*") %>
</p>
<p>
<label for="Zipcode">Zipcode:</label><%= Html.TextBox("Zipcode") %><%= Html.ValidationMessage("Zipcode", "*") %>
</p>
<p><input type="submit" value="Create" /> </p>
</fieldset>
<% } %>
<div><%=Html.ActionLink("Back to List", "Index") %></div>
 Validao no servidor Viso Details
<h2>Details</h2>
<fieldset>
<legend>Fields</legend>
<p>
Id:<%= Html.Encode(Model.Id) %>
</p>
<p>
Name:<%= Html.Encode(Model.Name) %>
</p>
<p>
Age:<%= Html.Encode(Model.Age) %>
</p>
<p>
Street:<%= Html.Encode(Model.Street) %>
</p>
<p>
City:<%= Html.Encode(Model.City) %>
</p>
<p>
State:<%= Html.Encode(Model.State) %>
</p>
<p>
Zipcode:<%= Html.Encode(Model.Zipcode) %>
</p>
</fieldset>
<p><%=Html.ActionLink("Back to List", "Index") %></p>

Para obter mais informaes e tutoriais, acesse: http://www.asp.net/mvc/tutorials/mvc-5/introduction/getting-started

 Validao no servidor - Os contras
Qual o problema dessa aproximao?
Novamente, a realidade nos indica que,
mediante outros meios, mais simples fazer
validaes no computador do usurio, e no
sobrecarregar nosso aplicativo com tarefas
desnecessrias. Para isso, se utilizam
tecnologias como Javascript ou JQuery, que
validam o formato dos dados diretamente no
navegador dos usurios, e economizam
processamento no servidor.
 Validao no cliente - Javascript
<!DOCTYPE html>
<html>
<head>
<script>
function validateForm()
{
var x=document.forms["myForm"]["fname"].value;
if (x==null || x=="")
{
alert("First name must be filled out");
return false;
}
}
</script>
</head>

<body>
<form name="myForm" action="demo_form.asp" onsubmit="return validateForm()" method="post">
First name: <input type="text" name="fname">
<input type="submit" value="Submit">
</form>
</body>

</html>
 Validao no cliente - Javascript
Na funo anterior, o que fazemos ao enviar o formulrio chamar uma funo de Javascript

chamada validateForm, a qual controla se o contedo desse campo null ou vazio. Em caso
positivo, abrir um popup para informar o erro. A mesma coisa pode ser feita para validar um e-
mail:
<script>
function validateForm()
{
var x=document.forms["myForm"]["email"].value;
var atpos=x.indexOf("@");
var dotpos=x.lastIndexOf(".");
if (atpos<1 || dotpos<atpos+2 || dotpos+2>=x.length)
{
alert("Not a valid e-mail address");
return false;
}
}
</script>
 Validao no cliente
Finalmente, existe outro tipo de validaes que
utiliza a tecnologia JQuery, a qual muito
simples. Alguns exemplos podem ser consultados
em: http://jqueryvalidation.org/

Quaisquer desses ltimos dois tipos de validaes

podem ser feitas do lado do usurio,
economizando recursos no servidor para que
nosso aplicativo possa focalizar outro tipo de
processamentos.
 Envio de correios
H diversas formas de enviar correios eletrnicos
a partir de nosso aplicativo. H formas mais
simples e mais complexas. Neste caso,
tentaremos enviar um e-mail em poucos passos,
utilizando bibliotecas gratuitas que funcionaro
com nosso modelo MVC.
Criamos um novo projeto em Visual Studio, como
j vimos antes, escolhendo um projeto web MVC.
A seguir, criamos uma nova classe na pasta
Model, chamada correoModel.cs, cujo cdigo
ser:
 Envio de correios - Modelo
public class CorreoModel
{
public string From { get; set; }
public string To { get; set; }
public string Subject { get; set; }
public string Body { get; set; }
}
Logo, na pasta Controller, criaremos um novo
controlador, chamado EnviarCorreoController
 Envio de correios - Controlador
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Mail;
using System.Web;
using System.Web.Mvc;
namespace EnviarCorreo.Controllers
{
public class EnviarCorreoController : Controller
{
//
// GET: /EnviarCorreo/
public ActionResult Index()
{
return View();
}
[HttpPost]
public ViewResult Index(EnviarCorreo.Models.CorreoModel _objModelMail)
{
if (ModelState.IsValid)
{
MailMessage mail = new MailMessage();
mail.To.Add(_objModelMail.To);
mail.From = new MailAddress(_objModelMail.From);
mail.Subject = _objModelMail.Subject;
string Body = _objModelMail.Body;
 Envio de correios - Controlador
mail.Body = Body;
mail.IsBodyHtml = true;
SmtpClient smtp = new SmtpClient();
smtp.Host = "smtp.outlook.com";
smtp.Port = 587;
smtp.UseDefaultCredentials = false;
smtp.Credentials = new System.Net.NetworkCredential
("username", "password");// Enter seders User name and password
smtp.EnableSsl = true;
smtp.Send(mail);
return View("Index", _objModelMail);
}
else
{
return View();
}
}
}
}
E, finalmente, na pasta Viso, teremos Index.cshtml
 Envio de correios - Viso
@model EnviarCorreio.Models.CorreioModel
@{
ViewBag.Title = "Index";
}
<h2>Index</h2>
<fieldset>
<legend>
Send Email
</legend>
@using (Html.BeginForm())
{
@Html.ValidationSummary()
<p>From: </p>
<p>@Html.TextBoxFor(m=>m.From)</p>
<p>To: </p>
<p>@Html.TextBoxFor(m=>m.To)</p>
<p>Subject: </p>
<p>@Html.TextBoxFor(m=>m.Subject)</p>
<p>Body: </p>
<p>@Html.TextAreaFor(m=>m.Body)</p>
<input type ="submit" value ="Send" />
} </fieldset>
 Explicamos nosso exemplo
No controlador, temos um cdigo que diz:
ViewResult Index (EnviarCorreio.Models.CorreioModel
_objModelMail)
Nesse mtodo, temos um dado que tem a forma de nosso
CorreioModel. Logo, criamos um dado MailMessage e
completamos toda a informao necessria:
To
From
Cc
Bcc
Subject
Body
 Explicamos nosso exemplo
A seguir, configuramos os dados do servidor de correio,
o qual enviar nosso e-mail com os dados a seguir:
Host: o nome do servidor
Port: a porta qual nos conectamos para enviar o correio
UseDefaultCredential: indica se houver algum usurio pr-
configurado
Credentials: usurio e senha
EnableSsl: indica se as informaes so encriptadas com
um tipo de segurana chamada SSL
E, finalmente, indicamos ao servidor que envie o
correio utilizando a funo Send
 Interfaces avanadas
Com funes, como a validao, e o uso de
controladores e modelos podemos construir
interfaces cada vez mais complexas e avanadas,
as quais permitiro uma interao maior do
usurio, sem precisar um grande processamento
do lado do servidor de maneira constante. Se
adicionarmos tecnologias, como AJAX ou JQuery,
mais HTML e CSS, teremos um sem fim de
possibilidades para oferecer a nossos usurios e
para representar melhor nosso modelo de
negcio.
 Interfaces avanadas
Para o desenvolvimento de interfaces
avanadas, deveremos usar sempre
tecnologias mltiplas que se complementaro
para ajudar-nos a atingir nossos objetivos.
possvel atingir algumas funcionalidades
avanadas de interface grfica mediante
bibliotecas como JQuery UI:
https://jqueryui.com/
 Interfaces avanadas
Se adicionarmos a potencia de .NET MVC para controlar o modelo de
negcios e de dados, mais a tecnologia oferecida por Javascript e AJAX
para evitar o super processamento, e que permite, entre outras coisas,
validar dados do lado do browser, podemos conseguir interfaces como:
http://www.microsoft.com/en-us/default.aspx
http://www.microsoft.com/surface/en-us
http://windows.microsoft.com/en-us/windows/home
http://whois.wildlife.la/
http://www.fk-agency.com/
http://www.sweez.com.br/
http://www.l2systems.com
http://www.tridentpp.com/
http://shibui.me/web/scroll/index.html
http://flashvhtml.com/
http://nasaprospect.com/
 Persistir
At agora, armazenamos nossos dados em variveis dentro
de nosso aplicativo, ou enviando-os por correio eletrnico.
Mas, nenhuma dessas opes parece ser a tima.
Armazenar nossos dados em variveis significa que eles so
armazenados na memria voltil de nosso computador.
Cada vez que desligamos nosso computador, perderemos
os dados e deveremos comear novamente com a carga.
Da mesma maneira, armazenar informaes em correios
eletrnicos tambm no uma opo vivel, pois vamos
trabalhar somente com informaes escritas, e no ser
fcil consultar essas informaes mais tarde, pois geramos
arquivos por cada uma das transaes que realizemos
 Persistir
Por isso, aparece, como uma necessidade, o
conceito de persistncia. Ele se refere
propriedade dos dados, para eles sobreviverem
de alguma maneira.
A persistncia do aplicativo a capacidade de os
dados sobreviverem execuo do programa
que os criou.
Esse tipo de persistncia requere que os dados
sejam armazenados em algum lugar no voltil
(ou seja, que eles no desapaream quando o
computador for desligado) para serem utilizados
no futuro.
 Persistir
Por exemplo, possvel armazenar informaes
em um arquivo armazenado em um disco.
comum em muitos aplicativos armazenar em
disco uma cpia das opes de configurao,
cada vez que o usurio introduzir mudanas. Se
essas mudanas no se armazenassem em um
disco, o usurio teria que definir outra vez as
opes de preferncia ao executar o aplicativo
novamente.
Outra maneira de armazenar informaes
mediante os servidores de bancos de dados. Mas
vamos falar nisso no prximo captulo.