Aprendendo a Programar

Capítulo VII
O servidor web. Conceitos avançados
 Validação
• O que é a validação? Imaginemos que vocês têm um site na
web, onde as pessoas se cadastram. Ou seja, criam seu usuário.
Isso é feito todos os dias, para obter uma conta de correio
eletrônico, ou ativar uma rede social.
• Nessa tela de cadastramento, precisam completar muitas
informações; por exemplo, nome, sobrenome, data de
nascimento, telefone, endereço, país, cidade, endereço de
correio eletrônico, 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 são palavras. O correio
eletrônico tem o símbolo “@” e um “.” , o número telefônico
tem números y, em alguns casos, “-“ ou parênteses.
 Validação
• Mas, o que acontece na realidade? Como o espaço para inserir
dados nem sempre está programado corretamente, o usuário
poderia inserir dados de natureza errada em nossa interface e,
portanto, teríamos informações incorretas, ou dados sujos.
Assim, o usuário poderia dizer que seu correio eletrônico é, por
exemplo, “João da Silva@ola”. Ou que sua data de nascimento é
“milnovecentos”.
• Por esse motivo, é feita o que chamamos validação de dados.
Isso é, basicamente, corroborar que os dados tenham o tipo e
a forma adequados. Isso não significa que o usuário não possa
mentir, mas, no mínimo, garantimos que os dados cumpram
determinadas regras.
 Validação no servidor
• A validação pode ser feita enviando as informações para o
servidor, para que ele as analise e, depois, o aplicativo decida se
elas têm o formato correto e as aprove, ou se serão exibidas
mensagens na interface com os erros encontrados.
• Podemos fazer isso utilizando novamente a estrutura de meu
modelo MVC, cuja visão requeira ao usuário inserir informações,
para que, logo, o controlador envie essas informações para o
modelo. Assim, o modelo decidirá como se atualizará a visão,
levando em conta se os dados inseridos são corretos ou não.
• Como exemplo, vamos mostrar quais seriam os componentes
MVC para inserir um novo dado Pessoa, e outra interface para
poder consultar os dados.
 Validação 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; }
}
}
Validação 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");
}
}
 Validação no servidor - Visão 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>
 Validação no servidor - Visão 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>
 Validação no servidor – Visão 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 informações e tutoriais, acesse: http://www.asp.net/mvc/tutorials/mvc-5/introduction/getting-started

 Validação no servidor - Os contras
• Qual é o problema dessa aproximação?
Novamente, a realidade nos indica que, mediante
outros meios, é mais simples fazer validações no
computador do usuário, e não sobrecarregar
nosso aplicativo com tarefas desnecessárias. Para
isso, se utilizam tecnologias como Javascript ou
JQuery, que validam o formato dos dados
diretamente no navegador dos usuários, e
economizam processamento no servidor.
 Validação 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>
 Validação no cliente - Javascript
• Na função anterior, o que fazemos ao enviar o formulário é chamar uma função de Javascript

chamada validateForm, a qual controla se o conteúdo 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>
 Validação no cliente
• Finalmente, existe outro tipo de validações que
utiliza a tecnologia JQuery, a qual é muito simples.
Alguns exemplos podem ser consultados em:
http://jqueryvalidation.org/

• Quaisquer desses últimos dois tipos de validações

podem ser feitas do lado do usuário, economizando
recursos no servidor para que nosso aplicativo
possa focalizar outro tipo de processamentos.
 Envio de correios
• Há diversas formas de enviar correios eletrônicos 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 funcionarão 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 código 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 Visão, teremos Index.cshtml 
 Envio de correios - Visão
@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 código que diz:
– ViewResult Index (EnviarCorreio.Models.CorreioModel
_objModelMail)
• Nesse método, temos um dado que tem a forma de nosso
CorreioModel. Logo, criamos um dado MailMessage e
completamos toda a informação necessária:
– 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 usuário pré-
configurado
– Credentials: usuário e senha
– EnableSsl: indica se as informações são encriptadas com um
tipo de segurança chamada SSL
• E, finalmente, indicamos ao servidor que envie o correio
utilizando a função Send
 Interfaces avançadas
• Com funções, como a validação, e o uso de
controladores e modelos podemos construir
interfaces cada vez mais complexas e avançadas, as
quais permitirão uma interação maior do usuário,
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 usuários e para representar
melhor nosso modelo de negócio.
 Interfaces avançadas
• Para o desenvolvimento de interfaces
avançadas, deveremos usar sempre
tecnologias múltiplas que se complementarão
para ajudar-nos a atingir nossos objetivos. É
possível atingir algumas funcionalidades
avançadas de interface gráfica mediante
bibliotecas como JQuery UI:
https://jqueryui.com/
 Interfaces avançadas
• Se adicionarmos a potencia de .NET MVC para controlar o modelo de negócios 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 variáveis dentro de
nosso aplicativo, ou enviando-os por correio eletrônico. Mas,
nenhuma dessas opções parece ser a ótima. Armazenar nossos
dados em variáveis significa que eles são armazenados na
memória volátil de nosso computador. Cada vez que desligamos
nosso computador, perderemos os dados e deveremos começar
novamente com a carga.
• Da mesma maneira, armazenar informações em correios
eletrônicos também não é uma opção viável, pois vamos
trabalhar somente com informações escritas, e não será fácil
consultar essas informações mais tarde, pois geramos arquivos
por cada uma das transações que realizemos
 Persistir
• Por isso, aparece, como uma necessidade, o conceito
de persistência. Ele se refere à propriedade dos dados,
para eles sobreviverem de alguma maneira.
• A persistência do aplicativo é a capacidade de os
dados sobreviverem à execução do programa que os
criou.
• Esse tipo de persistência requere que os dados sejam
armazenados em algum lugar não volátil (ou seja, que
eles não desapareçam quando o computador for
desligado) para serem utilizados no futuro.
 Persistir
• Por exemplo, é possível armazenar informações em um
arquivo armazenado em um disco. É comum em muitos
aplicativos armazenar em disco uma cópia das opções
de configuração, cada vez que o usuário introduzir
mudanças. Se essas mudanças não se armazenassem em
um disco, o usuário teria que definir outra vez as opções
de preferência ao executar o aplicativo novamente.
• Outra maneira de armazenar informações é mediante os
servidores de bancos de dados. Mas vamos falar nisso
no próximo capítulo.