ClipaTec Informática

O que é Markdown?

2025-05-15T12:32:00.000-03:00

Olá meus caros, já ouviram falar sobre Markdown? O que é? Para que serve? Qual a relação com o HTML?

Neste post, vamos responder essas dúvidas, então vem comigo.

1 - O que é Markdown?

Em síntese, é uma linguagem de marcação leve com sintaxe de formatação de texto plano simples, criada por John Gruber em 2004. É fácil de aprender e ler, visto que, o foco está na escrita e não na formatação complexa e tem a capacidade de ser convertida para HTML e outros formatos para que seja exibido de forma formatada em navegadores e outras plataformas.

Podemos dizer que, a Markdown é uma forma de estilizar textos usando caracteres comuns ao invés de usar tags complexas como no HTML. Com ele, podemos usar símbolos simples para criar títulos, listas, negrito, itálico, links, imagens, etc.

Abaixo, temos alguns exemplos simples de Markdown:

Título de nível 1: # Meu Título
Título de nível 2: ## Subtítulo
Texto em negrito: **Texto em negrito** ou _ _Texto em negrito_ _
Texto em itálico: *Texto em itálico* ou _Texto em itálico_
Lista não ordenada:

- Item 1
- Item 2
- Item 3

Lista ordenada:

1. Primeiro item
2. Segundo item
3. Terceiro item

Link: [Texto do link](https://www.clipatecinformatica.com.br)
Imagem: ![Texto alternativo da imagem](caminho/da/imagem.jpg)

2 - Para que serve?

Podemos dizer então, que o Markdown serve para simplificar o processo de escrita de conteúdo formatado, especialmente para a web. Existem algumas vantagens em usar o Markdown, por exemplo:

Facilidade de escrita: A sintaxe do Markdown é muito mais leve e intuitiva do que o HTML, o que torna a escrita mais rápida e focada no conteúdo.
Legibilidade: Textos em Markdown são mais fáceis de ler, mesmo em sua forma original, dispensando a necessidade de interpretar várias tags HTML.
Portabilidade: Por ser texto plano, isso o torna altamente portável e compatível com diversos editores de textos e plataformas.
Conversão fácil: Existem inúmeras ferramentas e bibliotecas disponíveis para converter Markdown para HTML e outros formatos como, PDF, ePub, etc.
Popularidade: É amplamente utilizado em diversas plataformas como GitHub (para arquivos README, comentários, issues), Reddit, Stack Overflow, editores de texto e aplicativos de anotação.

3 - Qual a relação com o HTML?

É importante ressaltar que, o Markdown não é um concorrente do HTML, mas sim, um facilitador para a criação de HTML. A principal relação entre eles é que o texto formatado em Markdown é geralmente convertido para HTML através de um software denominado "processador de Markdown" ou "parser".

Ao escrever um arquivo em Markdown (geralmente com a extensão ".md"), ele é um arquivo de texto simples. Para que essa formatação seja exibida corretamente em um navegador web ou outro aplicativo que interprete HTML, o texto Markdown precisa ser processado e transformado nas tags HTML correspondentes.

Vamos a um exemplo de texto em Markdown e sua conversão para HTML:

Texto em Markdown:

# Este é um título

Isto é um **texto em negrito**

- Item de uma lista não ordenada

Convertido para HTML:

<h1>Este é um título</h1>

<p>Isto é um <strong>texto em negrito</strong>.</p>

<ul>

<li>Item de uma lista não ordenada</li>

</ul>

Podemos concluir então que, o Markdown não substitui o HTML em sua totalidade. O HTML é uma linguagem de marcação muito mais poderosa e expressiva, capaz de escrever a estrutura e conteúdo de páginas web complexas, incluindo elementos interativos, scripts, estilos avançados, etc.

O Markdown concentra-se em fornecedor uma sintaxe simples para as necessidades de formatação mais comuns de texto. Para layouts complexos e funcionalidades avançadas na web, o HTML combinado com CSS e JavaScript continua sendo essencial.

4 - Curiosidade

O WhatsApp implementa um subconjunto de sintaxe do Markdown para permitir a formatação básica de texto diretamente nas mensagens. Por exemplo:

*teste* é a sintaxe padrão do Markdown para negrito
_teste_ é uma das sintaxes padrão do Markdown para itálico
~tachado~ é uma sintaxe para tachar texto
* Item ou - Item para lista não ordenada
1 . Lista ordenada
> Texto de citação

Obviamente o WhatsApp não implementa todos os caracteres do Markdown, mas temos alguns deles disponíveis para formatar textos de mensagens de maneira intuitiva e rápida, sem a necessidade de interfaces de edição ricas ou botões de formatação complexos.

Isso permite que a formatação seja feita diretamente no fluxo da digitação, usando caracteres que já estão presentes nos teclados dos dispositivos móveis, tornando mais prático com essa abordagem, ao invés de ter que selecionar texto e escolher opções de formatação em um menu.

5 - Conclusão

Resumindo tudo o que vimos até aqui, podemos dizer que o Markdown é uma linguagem de marcação leve e simples para formatar texto plano, onde, sua principal função é ser facilmente convertido para HTML para exibição formatada. Ele não é um concorrente do HTML, mas sim, uma ferramente que facilita a criação de conteúdo HTML para as necessidades mais comuns. É amplamente utilizado devido à sua facilidade de uso e legibilidade.

Para quem está começando no desenvolvimento web, aprender Markdown é uma habilidade valiosa, especialmente para criar documentação, arquivos README e conteúdo simples para web de forma rápida e eficiente.

(Por ClipaTec Informática)

Regex - Introdução às Expressões Regulares

2024-06-19T12:52:00.049-03:00

Fala dev! Provavelmente você já deve ter ouvido falar sobre expressões regulares ou regex, mas que diabos é isso? Para que serve?

Neste artigo, daremos uma introdução sobre o assunto, entender seus elementos e como aplicar esse recurso em validação de dados.

O que são Expressões Regulares?

Expressões regulares, também conhecida como regex ou regexp são sequências de caracteres que formam um padrão de busca. É um excelente recurso para buscar, manipular e validar texto com base em padrões específicos, ou seja, elas são utilizadas para corresponder strings ou partes de strings que seguem um determinado formato.

Sua origem se deu na década de 1950, e hoje são amplamente utilizadas em diversas linguagens de programação devido à sua capacidade de simplificar operações complexas de manipulação de strings.

Uma regex é composta de vários elementos, como caracteres literais, metacaracteres e quantificadores, que juntos definem o padrão a ser correspondido.

Principais elementos das Regex

Âncoras:

^: Início da string.
$: Fim da string.

Metacaracteres:

.: Qualquer caractere, exceto nova linha.
\: Caractere de escape para caracteres especiais.

Quantificadores:

*: Zero ou mais ocorrências.
+: Uma ou mais ocorrências.
?: Zero ou uma ocorrência.
{n}: Exatamente n ocorrências.
{n,}: n ou mais ocorrências.
{n,m}: Entre n e m ocorrências.

Grupos e Alternância:

() : Define um grupo.
| : Alternância (ou).

Classes de Caracteres:

\d: Qualquer dígito (0-9).
\w: Qualquer caractere de palavra (a-z, A-Z, 0-9, _).
\s: Qualquer espaço em branco (espaço, tab, nova linha).
[...]: Conjunto de caracteres. Exemplo: [abc] corresponde a 'a', 'b', ou 'c'.
[^...]: Conjunto negado de caracteres. Exemplo: [^abc] corresponde a qualquer caractere exceto 'a', 'b', ou 'c'.

Escape Sequences:

\\: Barra invertida literal.
\.: Ponto literal.
\D: Não dígito.
\W: Não caractere de palavra.
\S: Não espaço em branco.

Para que Servem as Expressões Regulares?

As expressões regulares são usadas para:

Validação: Verificar se um texto corresponde a um padrão específico, como endereços de e-mail, números de telefone, CPFs, etc.
Busca: Localizar ocorrências de padrões dentro de textos.
Substituição: Modificar texto substituindo padrões correspondidos por novos valores.
Extração: Extrair partes de um texto que correspondam a um padrão específico.

Quando Usar Expressões Regulares?

Utilize expressões regulares quando precisar de:

Verificação rápida e eficiente de formatos de entrada.
Manipulação complexa de strings que seria difícil de implementar com métodos tradicionais.
Processamento de grandes volumes de texto onde buscas e substituições precisam ser feitas rapidamente.

No entanto, evite usar regex quando:

Uma operação simples pode ser realizada sem regex.
A expressão regular se torna extremamente complexa, tornando o código difícil de ler e manter.
A performance é uma preocupação crítica e existem alternativas mais eficientes.

Exemplos Práticos

Vamos ver alguns exemplos práticos para reforçar a compreensão:

Validação de E-mail

^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

^[a-zA-Z0-9._%+-]+: Início da string seguido de um ou mais caracteres alfanuméricos ou ., _, %, +, -.
@: Símbolo @.
[a-zA-Z0-9.-]+: Um ou mais caracteres alfanuméricos, . ou -.
\.: Ponto literal.
[a-zA-Z]{2,}$: Dois ou mais caracteres alfabéticos até o final da string.

Validação de Telefone (Formato US)

^$\d{3}$ \d{3}-\d{4}$

^\(: Início da string seguido por um parêntese esquerdo literal.
\d{3}: Três dígitos.
\) : Parêntese direito literal seguido de um espaço.
\d{3}-\d{4}$: Três dígitos, um hífen, e quatro dígitos até o final da string.

Validação de CPF (Brasil)

^\d{3}\.\d{3}\.\d{3}-\d{2}$

^\d{3}: Três dígitos no início da string.
\.: Ponto literal.
\d{3}: Três dígitos.
\.: Ponto literal.
\d{3}: Três dígitos.
-: Hífen literal.
\d{2}$: Dois dígitos até o final da string.

Data (Formato DD/MM/YYYY)

^\d{2}/\d{2}/\d{4}$

^\d{2}: Dois dígitos no início da string.
\.: Ponto literal.
\d{4}$: Quatro dígitos até o final da string.

Validação de Valor Monetário (Brasil)

^-?\d{1,3}(\.\d{3})*(,\d{2})?$|^-?\d+(,\d{2})?$

^-?: Início da string seguido de um sinal negativo opcional.
\d{1,3}: Um a três dígitos.
(\.\d{3})*: Zero ou mais grupos de três dígitos precedidos por um ponto.
(,\d{2})?$: Uma vírgula seguida de dois dígitos (opcional) até o final da string.
|: Alternância (ou).
^-?\d+(,\d{2})?$: Início da string seguido de um sinal negativo opcional, um ou mais dígitos, e uma vírgula seguida de dois dígitos (opcional) até o final da string.

Vamos decompor essa última expressão de forma mais detalhada:

^:Âncora que indica o início da string.
-?: O hífen (-) seguido por um ponto de interrogação (?) indica que o sinal negativo é opcional.
\d{1,3}: \d corresponde a qualquer dígito (0-9). {1,3} significa que deve haver de 1 a 3 dígitos.
(\.\d{3})*: \. corresponde a um ponto literal. \d{3} significa três dígitos. O asterisco (*) indica que este grupo pode aparecer zero ou mais vezes.
(,\d{2})?: , corresponde a uma vírgula literal. \d{2} significa dois dígitos. O ponto de interrogação (?) indica que este grupo é opcional.
$: Âncora que indica o final da string.
|: Operador OR que separa duas alternativas.
^-?\d+(,\d{2})?$: Segunda parte da expressão regular:
^: Início da string.
-?: Sinal negativo opcional.
\d+: Um ou mais dígitos.
(,\d{2})?: Vírgula seguida por dois dígitos, opcional.
$: Final da string.

Conclusão

As expressões regulares são uma ferramenta extremamente útil para desenvolvedores e administradores de sistemas que precisam manipular texto de forma eficiente baseado em padrões. Compreender e utilizar regex pode melhorar significativamente a capacidade de validar, buscar, substituir e extrair informações de strings. A prática e o estudo contínuo são essenciais para dominar essa poderosa ferramenta.

Experimente criar suas próprias expressões regulares e veja como elas podem simplificar suas tarefas de manipulação de texto!

Dica: você pode testar as expressões regulares no site Regex101, divirtam-se! 😃

(Por ClipaTec Informática)

Paradigma de Programação Orientada a Objeto - O que é POO?

2024-06-14T10:07:00.001-03:00

Olá caro leitor, se você é estudante ou atua na área de desenvolvimento de aplicações, já deve ter ouvido um desses termos: POO, Programação Orientada a Objetos, Orientação a Objetos ou Paradigma de Programação Orientada a Objetos.

O que é? Para que serve? Qual o objetivo deste paradigma? Vamos esclarecer essas dúvidas, nesse artigo introdutório. Sigam-me.

A programação orientada a objetos (POO) é um dos paradigmas de programação mais utilizados no desenvolvimento de softwares. Ao contrário dos paradigmas de programação procedimental ou funcional, a POO se concentra em criar objetos que representam entidades do mundo real, tornando o desenvolvimento de software mais intuitivo e modular. Neste post, vamos explorar os conceitos básicos da POO e entender como ela pode transformar a forma como você escreve e organiza seu código.

O Que é Programação Orientada a Objetos?

A POO é um paradigma de programação baseado em conceitos de "objetos", que são instâncias de "classes". Uma classe define a estrutura e o comportamento de um objeto. Em termos simples, uma classe pode ser vista como um molde ou uma planta, enquanto os objetos são as instâncias concretas criadas a partir desse molde.

Conceitos Fundamentais da POO

1. Classes e Objetos

Classe: Uma classe é uma blueprint(planta) que define as propriedades e comportamentos de um objeto. Ela contém atributos (dados) e métodos (funções).

Exemplo de classe em Java:

public class Pessoa {

// Atributos (variáveis de instância)

private String nome;

private int idade;

// Construtor padrão

public Pessoa() {

this.nome = "";

this.idade = 0;

}

// Construtor com parâmetros

public Pessoa(String nome, int idade) {

this.nome = nome;

this.idade = idade;

}

// Método getter para o nome

public String getNome() {

return nome;

}

// Método setter para o nome

public void setNome(String nome) {

this.nome = nome;

}

// Método getter para a idade

public int getIdade() {

return idade;

}

// Método setter para a idade

public void setIdade(int idade) {

if (idade >= 0) {

this.idade = idade;

} else {

System.out.println("A idade não pode ser negativa.");

}

// Método para exibir informações da pessoa

public void exibirInformacoes() {

System.out.println("Nome: " + nome);

System.out.println("Idade: " + idade);

}

// Método principal para testar a classe

public static void main(String[] args) {

// Criando uma instância da classe Pessoa usando o construtor padrão

Pessoa pessoa1 = new Pessoa();

pessoa1.setNome("João");

pessoa1.setIdade(25);

pessoa1.exibirInformacoes();

// Criando uma instância da classe Pessoa usando o construtor com parâmetros

Pessoa pessoa2 = new Pessoa("Maria", 30);

pessoa2.exibirInformacoes();

}

Objeto: Um objeto é uma instância de uma classe. Ele possui as características e comportamentos definidos pela classe.

Exemplo de objeto em Java:

// Criando uma instância da classe Pessoa usando o construtor com parâmetros

Pessoa pessoa = new Pessoa("Maria", 30);
pessoa.exibirInformacoes();

2. Encapsulamento

Encapsulamento é o conceito de restringir o acesso direto a alguns atributos de um objeto, usando métodos públicos para interagir com esses atributos. Isso ajuda a proteger os dados e a ocultar a complexidade interna do objeto.

Exemplo de encapsulamento em Java:

// Método getter para o nome

public String getNome() {

return nome;

}

// Método setter para o nome

public void setNome(String nome) {

this.nome = nome;

}

3. Herança

Herança permite que uma classe herde atributos e métodos de outra classe. Isso promove a reutilização de código e a criação de hierarquias de classes.

Exemplo de herança em Java:

public class Fornecedor extends Pessoa {

// Atributos específicos do Fornecedor

private String empresa;

private String cnpj;

// Construtor padrão

public Fornecedor() {

super(); // Chama o construtor da classe Pessoa

this.empresa = "";

this.cnpj = "";

}

// Construtor com parâmetros

public Fornecedor(String nome, int idade, String empresa, String cnpj) {

super(nome, idade); // Chama o construtor da classe Pessoa

this.empresa = empresa;

this.cnpj = cnpj;

}

// Método getter para a empresa

public String getEmpresa() {

return empresa;

}

// Método setter para a empresa

public void setEmpresa(String empresa) {

this.empresa = empresa;

}

// Método getter para o CNPJ

public String getCnpj() {

return cnpj;

}

// Método setter para o CNPJ

public void setCnpj(String cnpj) {

this.cnpj = cnpj;

}

// Sobrescrevendo o método para exibir informações

@Override

public void exibirInformacoes() {

super.exibirInformacoes(); // Chama o método da classe Pessoa

System.out.println("Empresa: " + empresa);

System.out.println("CNPJ: " + cnpj);

}

// Método principal para testar a classe

public static void main(String[] args) {

// Criando uma instância da classe Fornecedor usando o construtor com parâmetros

Fornecedor fornecedor = new Fornecedor("Aparecido do Nada", 33, "ABC Ltda", "01.234.567/0001-89");

fornecedor.exibirInformacoes();

}

4. Polimorfismo

Polimorfismo permite que métodos em diferentes classes tenham o mesmo nome, mas comportamentos diferentes. Isso é útil para tratar objetos de diferentes classes de forma uniforme.

Exemplo de polimorfismo em Java:

public class Pessoa {

// Método para exibir informações da pessoa

public void exibirInformacoes() {

System.out.println("Nome: " + nome);

System.out.println("Idade: " + idade);

}

public class Fornecedor extends Pessoa {

// Sobrescrevendo o método para exibir informações

@Override

public void exibirInformacoes() {

super.exibirInformacoes(); // Chama o método da classe Pessoa

System.out.println("Empresa: " + empresa);

System.out.println("CNPJ: " + cnpj);

}

Vantagens da Programação Orientada a Objetos

Modularidade: Código é organizado em classes e objetos, facilitando a manutenção e o entendimento.
Reutilização de Código: A herança permite reutilizar código existente, economizando tempo e esforço.
Flexibilidade e Extensibilidade: Novas funcionalidades podem ser adicionadas com menos impacto no código existente.
Facilidade de Manutenção: Encapsulamento ajuda a proteger dados sensíveis e a modularizar o código, tornando a manutenção mais fácil.

Conclusão

A Programação Orientada a Objetos é um poderoso paradigma que ajuda a organizar e estruturar o código de uma maneira mais intuitiva e eficiente. Ao entender e aplicar conceitos como classes, objetos, encapsulamento, herança e polimorfismo, você pode desenvolver software mais robusto, reutilizável e fácil de manter. Se você está começando com POO, experimente implementar esses conceitos em seus projetos e veja como eles podem transformar a maneira como você escreve código.

Esperamos que este post tenha fornecido uma visão clara e útil sobre os fundamentos da POO. Fique à vontade para deixar suas perguntas e comentários abaixo!

(Por Welinton Dias)

REST APIs e Verbos HTTP: GET, PUT, POST e PATCH

2024-06-05T14:38:00.001-03:00

Olá pessoal, salve, salve.

No artigo anterior abordamos sobre o conceito de API, para que serve e quando usar.

Ainda seguindo neste tema, vamos fazer uma introdução a REST API e daremos um pouco mais de enfase nos verbos HTTP, citados no artigo anterior.

As REST APIs (Application Programming Interfaces) são interfaces que permitem a comunicação entre sistemas utilizando os princípios da arquitetura REST (Representational State Transfer). As REST APIs são amplamente utilizadas no desenvolvimento de aplicativos web e móveis devido à sua simplicidade, escalabilidade e flexibilidade. Neste artigo, abordaremos os conceitos básicos das REST APIs e os principais verbos HTTP utilizados: GET, PUT, POST e PATCH.

Conceito de REST APIs

REST é um estilo de arquitetura de software que define um conjunto de restrições e propriedades baseadas no protocolo HTTP. Uma API RESTful permite que os sistemas se comuniquem de maneira padronizada e estateless, ou seja, cada requisição do cliente para o servidor deve conter todas as informações necessárias para entender e processar a solicitação.

Os recursos em uma API RESTful são representados por URIs (Uniform Resource Identifiers) e podem ser manipulados utilizando os verbos HTTP. Esses recursos podem ser dados de uma aplicação, como usuários, produtos, pedidos, entre outros.

Verbos HTTP

Os verbos HTTP (ou métodos) são usados para indicar a ação que deve ser realizada em um recurso. A seguir, discutimos os quatro verbos mais comuns: GET, PUT, POST e PATCH.

GET

O verbo GET é utilizado para solicitar a representação de um recurso. Quando um cliente envia uma requisição GET, ele está pedindo ao servidor que retorne os dados de um recurso específico. O uso do GET é seguro e idempotente, o que significa que a mesma requisição pode ser feita múltiplas vezes sem alterar o estado do recurso.

Exemplo:

GET /api/usuarios/123

Essa requisição pode retornar os dados do usuário com o ID 123.

POST

O verbo POST é utilizado para criar um novo recurso no servidor. Quando um cliente envia uma requisição POST, ele está enviando dados ao servidor para que um novo recurso seja criado. Diferentemente do GET, o POST não é idempotente; múltiplas requisições POST podem resultar na criação de vários recursos.

Exemplo:

POST /api/usuarios

Content-Type: application/json

{

"nome": "João",

"email": "joao@example.com"

}

Essa requisição cria um novo usuário com o nome "João" e o email "joao@example.com".

PUT

O verbo PUT é utilizado para atualizar completamente um recurso existente ou para criar um novo recurso se ele não existir. Quando um cliente envia uma requisição PUT, ele está fornecendo uma representação completa do recurso que deve ser armazenada no servidor. O PUT é idempotente, o que significa que múltiplas requisições PUT com os mesmos dados não devem alterar o estado do recurso após a primeira aplicação.

Exemplo:

PUT /api/usuarios/123

Content-Type: application/json

{

"nome": "João",

"email": "joao@example.com"

}

Essa requisição atualiza completamente os dados do usuário com o ID 123.

PATCH

O verbo PATCH é utilizado para aplicar modificações parciais a um recurso. Diferentemente do PUT, que requer uma representação completa do recurso, o PATCH permite que apenas as mudanças necessárias sejam enviadas. O PATCH também é idempotente.

Exemplo:

PATCH /api/usuarios/123

Content-Type: application/json

{

"email": "joao_novo@example.com"

}

Essa requisição atualiza apenas o email do usuário com o ID 123, mantendo os outros atributos inalterados.

Conclusão

Entender os verbos HTTP GET, PUT, POST e PATCH é fundamental para trabalhar com REST APIs de maneira eficaz. Cada verbo tem seu propósito específico e, quando utilizado corretamente, pode garantir uma comunicação clara e eficiente entre o cliente e o servidor. As REST APIs são uma peça central na arquitetura de sistemas modernos, proporcionando uma maneira padronizada e escalável de interação entre diferentes componentes e serviços.

(Por ClipaTec Informática)

O que é API (Interface de Programação de Aplicações)?

2024-05-30T16:47:00.001-03:00

Olá clipatequeiros, salve, salve.

Você já deve ter ouvido falar sobre API, mas afinal, o que é? Para que serve? Onde usar?

O uso de API's tem sido muito alto ultimamente, então, vamos sanar essas dúvidas neste artigo.

Este artigo será parte de uma série de artigos sobre API, vamos explorar alguns tipos de API's e ver na prática como funciona. Então bora lá?

O que é uma API?

API, ou Application Programming Interface (Interface de Programação de Aplicações), pode ser definida como um conjunto de regras e definições que permitem a comunicação entre diferentes software. As APIs definem os métodos e dados que as aplicações podem utilizar para interagir umas com as outras, facilitando a integração e a troca de informações entre diferentes serviços e plataformas.

Como Funcionam as APIs?

As APIs funcionam como contratos de serviço entre duas aplicações: uma que oferece o serviço (provedor da API) e outra que o consome (cliente da API). Esses contratos especificam como os dados devem ser solicitados e fornecidos, geralmente através de chamadas HTTP em APIs baseadas na web.

Principais Componentes de uma API

Endpoint: Um URL específico onde um recurso está disponível. É o ponto de contato para a comunicação com a API.
Verbos HTTP: Métodos que definem a ação a ser realizada sobre os recursos. Os principais verbos são:
- GET: Recuperar dados de um recurso.
- POST: Criar um novo recurso.
- PUT: Atualizar completamente um recurso existente.
- PATCH: Atualizar parcialmente um recurso existente.
- DELETE: Remover um recurso.
Parâmetros: Dados adicionais enviados com a requisição, como parâmetros de consulta (query parameters), parâmetros de caminho (path parameters), e cabeçalhos (headers).
Corpo da Requisição/Resposta: Dados enviados na requisição ou recebidos na resposta, geralmente em formatos como JSON ou XML.

Tipos de APIs

APIs Web (HTTP/REST): Utilizam o protocolo HTTP e seguem os princípios REST (Representational State Transfer), que permitem a manipulação de recursos usando URLs.
APIs SOAP: Utilizam o protocolo SOAP (Simple Object Access Protocol), um protocolo baseado em XML que permite a troca de informações estruturadas.
APIs de Biblioteca: Conjunto de funções e rotinas expostas por uma biblioteca de software para ser utilizada por outras aplicações.
APIs de Sistema Operacional: Permitem que programas interajam com o sistema operacional, como APIs do Windows ou do Linux.

Exemplos de Uso de APIs

Integração de Serviços: Um aplicativo de viagens pode usar APIs de diferentes companhias aéreas para mostrar opções de voos em tempo real.
Autenticação: Serviços como OAuth permitem que aplicações autentiquem usuários através de contas de outros serviços (ex.: login com Google ou Facebook).
Mapas e Geolocalização: APIs como Google Maps permitem incorporar mapas e funcionalidades de geolocalização em aplicativos.
Pagamentos Online: APIs de pagamento, como PayPal ou Stripe, permitem processar transações financeiras de forma segura.

Vantagens das APIs

Modularidade: Permite que diferentes partes de um sistema sejam desenvolvidas e atualizadas independentemente.
Reutilização: Funcionalidades podem ser reutilizadas em diferentes aplicações, economizando tempo e recursos.
Interoperabilidade: Facilita a comunicação entre sistemas diferentes, possibilitando a integração de serviços de terceiros.
Eficiência: Automatiza processos e troca de informações, melhorando a eficiência operacional.

Conclusão

As APIs são fundamentais para a arquitetura de software moderna, permitindo a integração de serviços e a criação de ecossistemas de aplicações conectadas. Elas facilitam a comunicação entre diferentes sistemas, promovendo a reutilização de funcionalidades e a interoperabilidade entre plataformas.

(Por ClipaTec Informática)

Quick Tips - Delphi: como minimizar a aplicação na bandeja do Windows?

2023-01-19T14:42:00.004-03:00

Olá minha gente, salve, salve.

Você já deve ter usado algum aplicativo, que ao minimizar, vai para a bandeja do Windows, logo ali, perto do relógio.

Se você deseja implementar este recurso na sua aplicação e não sabe como fazer isso no Delphi, na dica de hoje, vamos aprender como fazer.

Geralmente, esse recurso é mais utilizando em aplicações do tipo serviço, mas, este recurso pode ser aplicado em qualquer aplicação.

Vamos imaginar o seguinte cenário, para facilitar o entendimento do recurso:

Suponha que você tem um ERP integrado a um app mobile, no qual, o ERP, precisa sincronizar determinados dados com o app mobile, por exemplo, pedidos feitos no app, precisam ser recebidos no ERP.

Para possibilitar esse sincronismo de dados, imaginemos que possui um serviço que deve ficar em execução, sendo ele, o responsável por este sincronismo, portanto, o mesmo não pode ser fechado.

O usuário pode fechar o serviço por engano, ou como dizia o chaves "sem querer querendo", se isso ocorre, após poucos minutos, ele vai te ligar, disparando uma torrente de xingamentos com todos os palavrões existentes 😤, e dizendo que seu produto é uma porcaria porque os pedidos feitos no app mobile não estão aparecendo no ERP, é sério, isso acontece as vezes, o usuário faz coisas que até Deus duvida, acredite.

Uma maneira de evitar esse tipo de situação, é programar um recurso que quando o usuário clicar para fechar ou minimizar a aplicação ou serviço, a mesma seria sempre minimizada na bandeja do Windows, sendo assim, continuaria em execução em segundo plano, evitando essa ligação amorosa do usuário 😤. Legal, mas como fazer isso no Delphi? Sigam-me os bons...

O que é a bandeja do sistema (System Tray - Systray)?

Em síntese, é uma área de notificação, também conhecida como área de status e barra de menus, dependendo do sistema operacional em uso, que fica localizado geralmente na barra de tarefas do sistema operacional, contendo ícones que permitem aos usuários acesso à aplicações, serviços ou funções do sistema, como por exemplo, spooler da impressora, volume do sistema, conexões de rede, relógio, antivírus e etc.

Os ícones podem indicar status de determinados processos que estão em execução no computador. Ao passar o mouse sobre os ícones, dar um duplo clique ou ainda, por meio do clique com o botão direito do mouse, é possível visualizar o status, acessar a aplicação ou serviço e até configurar, controlar o aplicativo associado.

A bandeja do sistema está disponível nos sistemas operacionais, seja desktop ou móvel(Windows, Mac OS, Linux, Android e iOS). No caso do Windows, geralmente fica no canto inferior direito, no Linux, geralmente fica no canto superior direito, tudo depende do sistema operacional em uso, podendo inclusive, alterar sua posição.

No Windows, a bandeja do sistema podem ter alguns comportamentos, como por exemplo:

Ao clicar duas vezes no ícone inicia o programa correspondente;
Exibir uma caixa de diálogo;
Ao passar o mouse sobre um ícone, uma mensagem pop-up ou status do processo poderá ser exibida;
Ao clicar com o botão direito do mouse em um ícone, pode abrir um menu de opções, controle de volume e etc.

Mas agora, chega de lero lero, cremos que ficou bem entendido a questão, agora vamos partir para a prática no Delphi.

Minimizando uma aplicação na bandeja do Windows com Delphi

No Delphi, o componente responsável por permitir essa implementação é o "TrayIcon", presente na unit "Vcl.ExtCtrls.TTrayIcon".

Este componente, cria um ícone na bandeja do sistema ao lado do relógio. Ele possui eventos para cliques do mouse, propriedades para menus e animação do ícone, além de métodos para mostrar dicas de balão.

Com o Delphi aberto, crie um novo projeto e adicione dois componentes: TTrayIcon(ícone de bandeja) e TApplicationEvents(eventos do aplicativo).

O objetivo do nosso exemplo é, quando o usuário minimizar o aplicativo, o formulário será oculto e o ícone de bandeja será carregado. Ao passar o mouse sobre o mesmo, será exibido um balão de dicas e ao dar um duplo-clique, o aplicativo será restaurado para a tela.

Então, mãos a obra, os códigos estão bem comentados, dispensando explicações massantes.

No evento "OnCreate" do formulário principal, implemente-o da seguinte maneira:

Agora, selecione o componente TApplicationEvents e no evento "OnMinimize", implemente assim:

Por fim, selecione o componente TTrayIcon e codifique o evento "OnDblClick":

Muito bem, só rodar a aplicação e testar. Assim chegamos ao final de mais uma dica rápida, um abraço, até a próxima.

Links

- TTrayIcon - Embarcadero;

(Por ClipaTec Informática)

Quick Tips - Delphi: Trabalhando com os métodos EncodeDate e DecodeDate

2023-01-16T14:59:00.004-03:00

Olá gente boa, tudo bem com vocês?

Na dica rápida de hoje, vamos abordar sobre dois métodos que podem ser úteis em suas rotinas do dia a dia. Estamos falando dos métodos "EncodeDate" e "DecodeDate".

EncodeDate

O método EncodeDate, presente na unit System.SysUtils, é uma função que, passados por parâmetro separadamente o dia, mês e ano, retornará uma data completa do tipo TDateTime.

Em determinados momentos, as vezes se torna necessário desmontarmos uma data, para efetuar cálculos ou qualquer outro tratamento com datas, como por exemplo, calcular o dia útil de uma determinada data para vencimento de faturas geradas no sistema em uma rotina de faturamento de venda por exemplo, e após isso, precisamos montar novamente a data com o dia correto.

Em um cenário como esse, entra em ação o método EncodeDate, que faz justamente isso, ele monta uma data completa, unindo o dia, mês e ano passados por parâmetro.

Algumas considerações acerca do método EncodeDate são:

O valor referente ao ano passado por parâmetro, deve ser de 1 a 9999;
O valor referente ao mês passado por parâmetro, é considerado válido de 1 a 12;
O valor referente ao dia, podem ir de 1 a 28, 29, 30 ou 31, dependendo do mês passado por parâmetro, por exemplo, para o mês 02 (fevereiro), podemos ter um cenário de 1 a 28 ou 1 a 29, dependendo do ano, se for bissexto;

Se os valores não estiverem dentro do intervalo, isto é, caso algum valor seja inválido, uma exceção será levantada.

Para vermos o funcionamento desse método na prática, criamos um exemplo que pede ao usuário informar um dia, mês e ano, e no final, o algoritmo exibirá a data completa (montada), de acordo com os dados informados. Segue o código:

Temos quatro variáveis, sendo uma para o dia, mês e ano do tipo Word, e uma para a data completa que será montada pela função, do tipo TDate (para considerarmos apenas a data, sem a hora), mas poderia ser do tipo TDateTime também, sem nenhum problema.

Após pedir ao usuário para informar cada um desses dados, os mesmos são guardados dentro de suas respectivas variáveis.

Em seguida, chamamos o método EncodeDate repassando esses dados entrados por parâmetro, e o retorno dessa função, será armazenado na variável lData.

Por fim, exibimos na tela a data gerada. Simples, fácil e prático.

Ok, se tem como encodar uma data, também tem como decodar. É nosso próximo assunto.

DecodeDate

Este método, também presente na unit System.SysUtils, faz o inverso do método anterior. Esta procedure, recebe por parâmetro uma data completa, e a mesma é desmontada pelo método, e esse desmembramento é devolvido dentro dos demais parâmetros para dia, mês e ano, que também devem ser passados por parâmetro, ou seja, o método quebra e retorna os valores para dia, mês e ano separadamente, de uma determinada data passada por parâmetro do tipo TDateTime.

Se o ano da data for negativo, os valores para dia, mês e ano será ZERO;

Para exemplificarmos na prática, criamos um algoritmo que lê a data atual do computador, e desmonta essa data, para exibirmos em uma mensagem de maneira extensa, segue o código:

Ao chamarmos o método DecodeDate, passamos por parâmetro, uma chamada para a função Date que retornará para o parâmetro a data atual do computador, logo em seguida, passamos uma variável para ano, mês e dia, que são do tipo Word.

Note que este método é uma procedure, ou seja, não retorna valor. Os valores separados para o dia, mês e ano são devolvido dentro das respectivas variáveis passadas por parâmetro, isso ocorre porque, este método, requer passagem por referência, sendo assim, as variáveis passadas por parâmetro serão manipuladas diretamente dentro do método DecodeDate, ao final de sua execução, as mesmas já vão conter os valores separados.
Por fim, apenas exibimos o conteúdo delas em uma mensagem impressa no console, agregando uma frase personalizada.
Muito bem clipatequeiros de plantão, assim chegamos ao final dessa dica, codifique os exemplos e teste.
Em algum momento esses métodos serão úteis pra você. Alguns programadores por desconhecerem esses métodos, ao precisar separar o mês de uma data por exemplo, recorrem aos famosos métodos Copy e Pos, mas esse malabarismo todo cai por terra, com a utilização desses métodos nativos apresentados nesse artigo.
Um grande abraço, e até a próxima.

Links

- EncodeDate - Embarcadero;

- DecodeDate - Embarcadero;

(Por ClipaTec Informática)

Descompactando arquivos com Delphi

2023-01-12T14:51:00.002-03:00

Ola clipatequeiros, tudo bem com vocês?
No artigo anterior, abordamos como implementar a compactação de arquivos com o Delphi de forma nativa, usando a classe TZipFile. Vemos o quão é simples, fácil e prático.

No artigo de hoje, vamos fazer o processo inverso, vamos aprender a descompactar arquivos ZIP usando a mesma classe de forma nativa.
Para isso, declaramos o método "DescompactarArquivos", cuja implementação segue abaixo:

A implementação é bem parecida com o método de compactação. Importante salientar que, é necessário dar uses na unit "System.Zip".
Declaramos quatro variáveis:

lArqZip: TZipFile - > que receberá a instância da classe TZipFile;
lOrigem: string -> que receberá o diretório onde se encontra o arquivo ZIP;
lDestino: string -> que receberá o diretório de destino, onde os arquivos contidos no arquivo ZIP serão extraídos;
lNome: string -> que receberá o nome do arquivo ZIP que será decompactado;

Por meio do método Open estamos preparando o arquivo para ser lido ou escrito. Como vamos fazer a descompactação do arquivo, então, note que agora, no último parâmetro deste método, estamos usando um indicador para leitura: zmRead, para indicar que estaremos lendo um arquivo ZIP criado anteriormente.

Após isso, basta chamar o método ExtractAll passando o diretório de destino por parâmetro, onde os arquivos serão extraídos. Este método, extrai todos os arquivos contidos no arquivo ZIP.
Por fim, chamamos o método Close para fechar o arquivo, embora, como ressaltamos no artigo anterior não se faz necessário chamar este método explicitamente, visto que, antes do objeto ser destruído, automaticamente o método Close é invocado pela biblioteca.

Assim chegamos ao fim de mais um tutorial, agora, só utilizar onde quiser dentro do seu sistema.

Links:

- TZipFile - embarcadero;

- Compactando arquivos com Delphi;

(Por ClipaTec Informática)

Compactando arquivos com Delphi

2023-01-12T08:35:00.008-03:00

Olá gente boa! No artigo de hoje, vamos aprender como implementar a compactação de arquivos, de forma nativa no Delphi.

Em versões mais antigas do Delphi, era comum utilizar a biblioteca "ZLib" presente na unit "System.ZLib", porém, utilizando essa biblioteca, tínhamos um problema, o arquivo compactado gerado não era compatível com outros aplicativos, como WinRar, 7Zip, etc, sendo assim, se o arquivo fosse enviado para alguém, este alguém não conseguiria abrir ou extrair este arquivo, a menos que, tivesse um aplicativo para isso, que utilizasse esta mesma biblioteca, para então conseguir abrir, visualizar e extrair.

Ora, isso não era interessante do ponto de vista usual, uma vez que, esta funcionalidade ficava "Delphi to Delphi", ou seja, só era possível descompactar usando um aplicativo, cuja implementação fosse feita com essa mesma biblioteca.

Nas versões novas do Delphi, surge a classe "TZipFile", presente na unit "System.Zip". Esta nova biblioteca, resolve o problema anterior.

A classe TZipFile é utilizada para criar e ler arquivos ".zip", ela dispõe de métodos para compactar e descompactar arquivos no formato .zip.

Ao implementar métodos para compactação e descompactação de arquivos usando a classe TZipFile, fica compatível com outros aplicativos do mercado, como o WinRAR, 7Zip por exemplo. Agora, você pode compactar arquivos, enviar para alguém, e este alguém, vai conseguir abrir e extrair esses arquivos sem problema algum, utilizando qualquer aplicativo que ele tenha instalado no computador para isso.

Muito bem, chega de teoria e vamos para a prática, segue abaixo o código para implementação da compactação de arquivos no Delphi:

Primeiro passo, é dar uses na unit "System.Zip" que contém a classe TZipFile, que vamos utilizar para esta implementação.
Feito isso, declaramos um método chamado "CompactarArquivos". Na implementação dele, declaramos três variáveis:

lArqZip: TZipFile -> que receberá uma instância da classe TZipFile;
lDestino: string -> que receberá o diretório onde será gerado o arquivo compactado;
lNome: string -> que receberá o nome do arquivo ZIP que será gerado;

Por meio do método Open, o arquivo é preparado para leitura ou gravação, e por parâmetro, passamos o local + nome do arquivo ZIP que será gerado. Note que neste método, no último parâmetro, estamos definindo que o arquivo será escrito/criado: zmWrite.

Através do método Add passamos por parâmetro o local + nome dos arquivos que serão adicionados no arquivo compactado ZIP.

Pronto, somente com essas linhas já teremos o arquivo ZIP gerado com os arquivos adicionados.

Note que não foi necessário chamarmos o método Close no final, visto que, o mesmo é chamado automaticamente na destruição do objeto.

Muito bem clipatequeiros, viram como é simples, fácil e prático? Agora, você pode usar esta implementação, modifica-la de acordo com suas necessidades, mais um recurso interessante que nos livra de ficar usando bibliotecas externas ou via linha de comando como outrora. Um grande abraço, que esta dica contribua de alguma maneira no seu dia a dia como programador.

Links:

- TZipFile - Embarcadero;

- Descompactando arquivos com Delphi;

(Por ClipaTec Informática)

Quick Tips - InputQuery com mais de um campo

2023-01-04T13:50:00.003-03:00

Olá clipatequeiros, no artigo de hoje, mostraremos uma dica rápida sobre o método InputQuery do Delphi.

Há um tempo, recebemos questionamentos sobre a possibilidade do método InputQuery ter mais de um campo para entrada de dados. A resposta é SIM, isso é possível. Poucos sabem, até mesmo, alguns programadores que já trabalham com Delphi há anos.

Se olharmos para a UNIT que contem o método InputQuery, note que existem algumas assinaturas de sobrecarga para este método (três), inclusive, uma delas, pede por parâmetro, um array, e é exatamente essa assinatura que usaremos para mostrar que podemos ter uma janela do InputQuery com mais de um campo para entrada de dados.

Assinatura do método InputQuery que vamos utilizar:

function InputQuery(const ACaption: string; const APrompts: array of string; var AValues: array of string; CloseQueryFunc: TInputCloseQueryFunc = nil): Boolean; overload;

Para isso, vamos trabalhar com array de genéricos, especializado em string.

O primeiro passo, é definir uma variável do tipo TArray de string, neste exemplo, trabalharemos com os dados como string. No código abaixo, chamamos esta variável do array de 'lDados'.

Após a declaração da variável, precisamos definir o tamanho do nosso array, isto é, definiremos quantas posições irá conter no array. É importante salientar que, o tamanho do array, deve corresponder à quantidade de campos que você deseja ter na janela do InputQuery, no nosso exemplo, teremos apenas três campos, sendo um campo para nome, E-Mail e telefone, sendo assim, teremos um array com três posições, onde, cada posição irá armazenar o dado de um campo.
O método usado para definirmos o tamanho do array é o SetLength, que pede por parâmetro o array e o tamanho dele.

Agora vem o pulo do gato, ao chamarmos o método InputQuery, utilizaremos a assinatura citada anteriormente, onde passaremos três parâmetros, o primeiro é o título da janela, o segundo é o array com os títulos dos campos que irão conter na janela, vale ressaltar que, por ser um array, devemos passar entre colchetes '[]', separados por vírgula. Note que, passamos três valores neste array de títulos dos campos, ou seja, deve ser exatamente a quantidade de elementos definidos no array, no nosso caso, três, para não ter estouro de posição. Por fim, o terceiro parâmetro é o nosso array.

Ao executar, a janela do InputQuery agora terá três campos, cada um, com o título que definimos na passagem do parâmetro, e repare que os campos aparecem na janela, na mesma ordem em que foram passados no parâmetro, é muito importante lembrar desse detalhe.

Estamos testando o retorno dessa função dentro de um IF, se o usuário clicar no botão OK, apenas exibiremos uma mensagem mostrando os dados que foram informados na janela, se o usuário clicar no botão CANCELAR, mostraremos uma mensagem dizendo que a operação foi cancelada, conforme o código abaixo.

Agora, note que ao recuperar os dados informados para exibir na mensagem, estamos acessando o array e suas posições, onde, a posição ZERO corresponde ao Nome, a posição UM corresponde ao E-Mail e a posição DOIS corresponde ao Telefone. Vale ressaltar que as posições de um array começa com ZERO.

Por isso é importante lembrar da ordem dos títulos dos campos passados por parâmetro, pois, na hora de ler os dados, a sequência é a mesma. Atente-se a isso para não ler dado de posição errada. Os dados armazenados no array, são referentes aos campos na ordem passada no parâmetro do InputQuery.

Muito bem, feito isso, chegamos ao final desta dica rápida, se você não conhecia, agora já sabe como criar uma janela de InputQuery com vários campos. É um recurso que pode ser muito útil quando precisamos capturar dados de forma rápida e simples.

Código:

Links:

- TArray;
- InputQuery;

- TryStrToInt, InputBox e InputQuery no Delphi;

(Por ClipaTec Informática)

Loop "Para ate Faca": Exercício Tabuada

2018-08-22T15:20:00.001-03:00

Olá minha gente. Agora que já conhecemos as estruturas de repetição vamos praticar neste artigo, a estrutura de repetição "para ate faca", que é um laço iterativo. O exercício que vamos praticar, é bem simples e muito utilizado dentro dos ambientes acadêmicos, no qual, vamos desenvolver um algoritmo que entre com um determinado número que será informado pelo usuário, e em seguida, imprimimos na tela a tabuada do número digitado.

Utilizaremos o laço "para ate faca" para montar esta tabuada. A lógica é bem simples. O algoritmo será escrito em pseudocódigo (portugol) e a ferramenta didática utilizada para execução do mesmo será o visualg. O link para download se encontra no final do artigo.
Antes de iniciarmos o algoritmo, é importante ressaltar que, o laço para ate faca é um laço iterativo, que sabe o momento de parar por já ter definido a quantidade de vezes que um determinado trecho de código será repetido. Mas como ele vai controlar a quantidade de repetições que já foram realizadas? Por meio da variável de controle. Normalmente, chamamos esta variável de "I, J, K, Cont, Contador ou Controle", mas isso pouco importa, você pode dar o nome que você preferir, o que importa, é que esta variável seja do tipo inteiro, pois ela, será responsável por contar, controlar, a quantidade de repetições do laço. Deve ser inteiro porque não existe "meia repetição", então, jamais esta variável de controle pode ser do tipo real por exemplo. A cada repetição, esta variável de controle recebe um incremento de 1 (um) por padrão, ou seja, a variável de controle vai somando 1 (um) a cada iteração, até chegar no valor limite definido. Ao chegar no valor limite, o laço encerra a repetição, e o algoritmo segue executando as próximas linhas, caso haja.
O incremento pode ser definido no laço, caso não seja definido, por padrão é um, mas você pode dizer que o incremento seja de dois, três, etc. Agora vamos praticar. Analisando a proposta do exercício, o algoritmo precisa saber de qual número ele exibirá a tabuada, esta entrada de dados, será definida pelo usuário, então, o algoritmo deve solicitar ao usuário qual é este número. Neste exemplo, vamos trabalhar com tabuadas de números inteiro apenas.
Após o usuário informar o número que ele deseja imprimir a tabuada, o algoritmo deve guardar este número dentro de uma variável para ser utilizado posteriormente, então, vamos criar uma variável chamada "Numero" do tipo inteiro que armazenará o número digitado pelo usuário.
Como utilizaremos o laço para ate faca, então precisamos criar uma variável de controle, vamos chamá-la de "I", do tipo inteiro.
Agora pare, e pense, precisamos multiplicar o número digitado por zero, depois por um, dois até dez e mostrar o resultado de cada multiplicação.
Com base nisso, precisamos criar uma variável que irá calcular estas multiplicações, então, criaremos mais uma variável do tipo inteiro com o nome "Mult". Lembrando que o nome pode ser qualquer um de sua preferência, a minha dica é, sempre procure usar nomes bem claros e objetivos, para que, quando você olhar o algoritmo, você já consiga lembrar pra que server cada uma delas.
Agora vem a mágica do laço para ate faca, como precisamos multiplicar o número pela sequência de zero até dez, então já podemos notar que o laço para ate faca será propício, ele iniciará com zero e vai se repetir até dez, incrementando um a cada repetição, e dentro de cada repetição já calculamos a multiplicação e exibimos para o usuário. Fácil né? Segue o algoritmo:

Algoritmo "Tabuada"
// declaracao de variaveis

Var

Numero, Mult, I: inteiro

Inicio
// ler numero digitado pelo usuario

escreval("Informe a tabuada a ser exibida:")

leia(Numero)
// multiplicar numero pela sequencia de zero ate dez

para I de 0 ate 10 faca

Mult <- -="" font="" i="" numero="">

escreval(Numero, " X ", I, " = ", Mult)

fimpara

Fimalgoritmo

Muito bem, como podemos observar, a cada repetição, a variável "Mult" lê o número digitado pelo usuário e multiplica por "I", sendo que, na primeira repetição o valor de "I" é zero, na próxima é um e assim sucessivamente até dez, em seguida, já imprimimos o resultado para o usuário. No final da execução, teremos a tabuada montada.
Qualquer dúvida, deixe seu comentário. Até o próximo.

Download

- Interpretado e editor de algoritmos VISUALG;

(Por Welinton Dias)

Delphi: Função ParamStr

2018-08-20T15:37:00.000-03:00

Olá clipatequeiros. Neste artigo vamos entender a função "ParamStr" do Delphi.

Embora não muito utilizado, a passagem de parâmetros é muito útil quando precisamos chamar um programa passando algumas diretrizes ou informações relevantes para a execução do mesmo.

Isso acontece bastante quando se tem um aplicativo que chama outro por exemplo. Vamos imaginar a seguinte situação, onde temos um aplicativo desenvolvido em Java para enviar e-mail, e sua aplicação em Delphi, quando precisar enviar algum e-mail, chama este aplicativo em Java. Legal né, então, no momento em que o aplicativo Java for chamada, é necessário passar o e-mail do destinatário, o assunto e a mensagem propriamente dita, é aí que entra os parâmetros. Estas informações são repassadas ao aplicativo Java no momento da chamada, em linha de comando, o exemplo é bem didático, porém, perfeito para entender este recurso.

Este exemplo é interessante, porque, no momento em que o aplicativo Java for chamado, ele já tem os parâmetros necessários para poder enviar o e-mail, então, ele mostrará apenas uma barra de progresso "enviando e-mail..." automaticamente, dispensando a ação do usuário para clicar em um botão pra enviar por exemplo, isto, considerando que as informações do remetente já estejam configuradas no aplicativo Java.

Isso é muito interessante, porque podemos desenvolver pequenos aplicativos de apoio em outras linguagens e usar por meio de uma aplicação Delphi, apenas fazendo o uso de passagem de parâmetros.

Como funciona o ParamStr?

Parafraseando, no help e documentação do Delphi a respeito da função ParamStr, diz que ela retorna um parâmetro especificado da linha de comando CmdLine (nota 3) usada para chamar o programa atual por meio do seu índice ParamIndex (nota 1). Caso o índice seja inválido, como por exemplo, se o índice especificado for maior que o ParamCount (nota 2), isto é, um índice inexistente, ela retorna uma string vazia. Desta forma temos que, o índice 2 retorna o segundo parâmetro da linha de comando, o índice 3 retorna o terceiro parâmetro e assim sucessivamente, se passar um índice que não existe, é retornado uma string (texto) vazio. Acredito que com esta explicação até repetitiva, já deu pra entender esta primeira parte.

Por padrão, o ParamIndex 0 (zero), é reservado para o caminho do programa, ele representa o programa (executável) em si, portanto, não conseguimos atribuir valor a este índice, quando atribuímos algum parâmetro, ele sempre iniciará no índice 1.

Os parâmetros, são separados com um espaço em branco. Aí vem uma pergunta, e se precisar passar um valor que contenha espaço(s) em branco, como por exemplo, nomes de arquivos longos contendo espaço? Legal, no problem, basta passar o valor entre aspas duplas, com isso, ocorre um agrupamento de palavras e será interpretado como sendo o valor de um determinado parâmetro.

Notas

1 - ParamIndex

Refere-se ao índice especificado da linha de comando.

2 - ParamCount

Contabiliza e mostra a quantidade de parâmetros passados na linha de comando para o programa atual.

3 - CmdLine

Aponta para os argumentos da linha de comandos especificados ao chamar o programa, esta variável contém todo o texto da linha de comandos. Para acessar parâmetros individualmente, deve-se usar a função ParamStr.

(Por Welinton Dias)

Algoritmo e lógica de programação - Estruturas de repetição (loop)

2018-08-08T22:01:00.001-03:00

Olá clipatequeiros. Este artigo é voltado para os iniciantes em programação, que estão dando seus primeiros passos. Geralmente postamos coisas de nível médio e avançado, mas nosso objetivo é ajudar a todos, inclusive quem está começando agora, quanto mais programador melhor.

Vou abordar neste artigo a respeito das estruturas de decisão, também conhecidas por "loop" ou simplesmente laço de repetição. No desenvolvimento de software, estas estruturas são muito utilizadas. Em determinados momentos, precisamos repetir um determinado trecho de código (implementação) "n" vezes, é neste caso que entram as estruturas de repetição. Elas são muito úteis, até mesmo para reduzir códigos.

Podemos dividir as estruturas de decisão em dois grupos: iterativa e interativa. Uma letrinha a mais no nome, mas na prática, uma diferença considerável. Vamos ver um pouco sobre estes dois grupos de maneira bem resumida e direta (odeio enrolação, não leva a lugar nenhum e fica cansativo rsrsrs).

Praticamente, todas as linguagens de programação, disponibiliza três estruturas de repetição, são elas:

para ate faca
enquanto faca
repita ate

Digo "praticamente todas", porque desconheço alguma linguagem que não dê suporte a estas três estruturas, mas, vai que exista alguma por ai não é mesmo?

Estrutura de repetição iterativa (loop iterativo)

Dentro deste grupo, temos a estrutura de repetição, ou laço de repetição para ate faca.

Esta estrutura é utilizada quando já se tem o número de vezes definido que um determinado trecho de código será repetido. É dito iterativo porque dispensa a ação, interferência, interação do usuário para que o mesmo pare de se repetir, ou seja, ele vai se repetir até que o número de vezes definido seja satisfeito, dispensando a ação do usuário para pará-lo.

Vou apresentar uma situação simples, porém, vai te ajudar entender melhor. Imagine que um algoritmo precisa mostrar os números pares dentro de um intervalo de 1 até 10. Certo?

Note que já temos definido a quantidade de vezes em que este laço vai se repetir, isto é, dez vezes. Então este laço só vai parar após a décima repetição, não foi necessário o usuário intervir para parar a repetição, esta quantidade de vezes já foi predefino antes. Este laço é iterativo porque a cada repetição, a variável de controle do laço incrementa, adiciona, soma mais um.

Vejamos a sintaxe do laço para ate faca:

para "variavel_controle" de "valor_inicial" ate "valor_final" [passo "incremento"] faca

"sequencia_de_comandos"

fimpara

Onde:

"variavel_controle": é uma variável do tipo inteiro que vai controlar as repetições do laço;
"valor_inicial": definição do valor inicial para a variável_controle;
"valor_final": definição do valor limite para a variavel_controle;
"incremento": o valor a ser incrementado na variavel_controle;
"sequencia_comandos": parte do código (implementação) que será executada durante a repetição do laço;

Então, a variável de controle recebe um valor inicial para a contagem das repetições, e vai se repetir até que o valor final seja satisfeito, e, a cada repetição a variável de controle soma o valor do incremento. Este último, quando não passado, por padrão é sempre "um".
Em próximos artigos vamos trabalhar alguns algoritmos como exercícios práticos para entendermos melhor.

Estrutura de repetição interativa (loop interativo)

Dentro deste grupo, temos as estruturas "enquanto faca" e "repita ate".

Estas estruturas são utilizadas quando não temos previamente a quantidade de vezes que um determinado trecho de código irá se repetir. É dito interativo porque necessitada da ação do usuário para que o mesmo pare de se repetir. Essa interação do usuário vai ou não satisfazer uma condição de parada, desta maneira, quando tal condição for satisfeita o laço para de se repetir.

Imagine um algoritmo que cadastre nomes de pessoas, onde um menu será exibido ao usuário com duas opções: "Cadastrar" e "Sair". Sempre que o usuário escolher a opção "Cadastrar", o algoritmo pede para que o usuário digite o nome da pessoa, em seguida, o menu é exibido novamente. Percebe que, enquanto o usuário escolher a opção "Cadastrar", será necessário entrar com um nome a ser cadastrado, e quando, finalmente, o usuário escolher a opção "Sair", então, o laço para de se repetir, ou seja, a condição de parada do laço, é quando a opção escolhida for "Sair".
Essa é a diferença entre o laço iterativo e o laço interativo, este último, só para de se repetir, quando a condição de parada for satisfeita, neste caso, necessita-se da intervenção do usuário para isso. Então por que temos duas estruturas neste grupo?
Simples, o enquanto faca, o teste da condição de parada é feita no início, antes mesmo de entrar no laço, se o teste, ou expressão lógica, for satisfeita logo no início, então, o trecho de código dentro do laço nem chega a ser executado, já a estrutura repita ate, o teste da expressão lógica só é feito no final do laço, então, independente de tudo, o trecho de código dentro deste laço, sempre será executado pelo menos uma vez, ao chegar no fim, se a condição for satisfeita, o mesmo para, caso contrário, continua executando. Agora, cabe a você programador, analisar no seu dia a dia a necessidade do momento e escolher qual das duas estruturas interativas utilizar.
Vejamos a sintaxe do laço enquanto faca:

enquanto "condicao_de_parada" faca

"sequencia_de_comandos"

fimenquanto

Onde:

"condicao_de_parada": ou expressão lógica, representa o teste a ser realizado, se verdadeiro, o laço para, se falso, o laço continua executado. Esta expressão lógica é realizada a cada repetição, e deve ser do tipo booleana.

Agora, vejamos a sintaxe do laço repita ate:

repita
"sequencia_de_comandos"

ate "condicao_de_parada"

Neste caso, dispensa explicação, visto que é exatamente igual ao anterior, o que muda, é que o teste é feito no final do laço, e os comandos (repita..ate).

Também, faremos alguns algoritmos para praticar estas estruturas em próximos artigos, um grande abraço.

(Por Welinton J. Dias)

Cadastro Delphi POO + MVC + DAO - Camada View - Parte 6

2018-05-12T07:00:00.000-03:00

Aooooo meu povo, finalmente chegamos ao penúltimo artigo da nossa série de cadastro Delphi POO + MVC + DAO. Estamos felizes por ter acendido uma pequena luz nessa escuridão, algumas pessoas tem interagido outras entraram em contato, e isso é muito gratificante. Neste artigo vamos finalizar as implementações da camada VIEW.
Sem perca de tempo, com o projeto aberto no Delphi, acesse a tela de cadastro de cliente, selecione a "StringGrid" e implemente o evento "OnDrawCell" assim:

Esta implementação apenas pinta os títulos das colunas da Grid, para ter um destaque visual, caso as descrições dos títulos das colunas não aparecer, acrescente esta linha após a linha 340:

Canvas.TextOut(Rect.Left, Rect.Top, Cells[ACol,ARow]);

Agora vamos implementar o evento "OnDblClick" da "StringGrid", este evento é acionado quando o usuário der um duplo-clique sobre algum registro, ele apenas chama o método "Detalhar":

OK, agora, implemente o evento "OnShow" do formulário de cadastro assim:

Simplesmente, ao abrir a tela de cadastro de cliente, o método "SetUp" será chamado, e as configurações básicas para o bom funcionamento da tela serão realizadas.
Implemente o evento "OnKeyPress" da tela de cadastro desta maneira:

Este método verifica se a tecla "Enter" foi pressionada, caso sim, nós anulamos sua funcionalidade em seguida e chamamos a função "Tab", para que quando o usuário pressionar a tecla "Enter", ele consiga navegar entre os campos da tela.
Agora, vamos implementar os eventos "OnClick" dos seguintes botões:

Pesquisar

Novo

Detalhar

Excluir

Listar

Alterar

Gravar

Cancelar

Esta foi a parte mais simples, pois, apenas chamamos os métodos que já foram implementados nos botões. Desta maneira, finalizamos as implementações da camada VIEW, agora, no próximo artigo, vamos finalizar o projeto. Qualquer dúvida, só comentar, até o próximo, abraço.

Este artigo faz parte da série: CRUD Delphi POO + MVC + DAO;

(Por ClipaTec Informática)

Cadastro Delphi POO + MVC + DAO - Camada View - Parte 5

2018-05-11T06:00:00.000-03:00

Olá clipatequeiros de plantão. Estamos em reta final desta série de artigos, e no artigo de hoje, vamos continuar implementando os métodos da camada VIEW. Com o projeto aberto no Delphi, implemente o método "Gravar":

Conforme vimos no início da parte 3 vamos usar o Field "FOperacao", o qual, uma de suas finalidades é nortear o método gravar, rapidamente explicando, quando o usuário clicar no botão "Novo", este campo recebe um valor de tipo enumerado "opNovo", e quando o usuário clicar no botão "Alterar", este campo recebe um valor "opAlterar", desta maneira, agora aqui dentro do método "Gravar", fazemos uma verificação, se o valor deste campo é "opNovo", então o método "Gravar" vai chamar o método de inserção, caso for "opAlterar", o método de alteração será chamado.
Após o método Inserir ou Alterar for chamado, ao final da operação, se deu tudo certo, novamente chamamos o método de pesquisa para atualizar as informações.
Muito bem, agora implemente o método "Inserir":

Como você já deve estar habituado, não tem muito segredo, algumas linhas dispensa comentários e explicações. Basicamente um objeto do tipo "TCliente" é criado, e alimentado com as informações dos componentes que o usuário digitou, logo após, este objeto é enviado para a DAO por meio da Controller, onde as informações do mesmo será extraída e inserida na base de dados, se ocorrer algum erro, este erro é retornado dentro da variável "sErro" e exibida para o usuário como uma exceção.
Agora, vamos implementar o método que faz aquela mágica nos componentes para habilitar e desabilitar conforme a operação que está sendo realizada, então, mão na massa, implemente o método "HabilitarControles":

Como você percebeu, este método vai habilitar ou desabilitar os controles (TEdit, TButton, etc) conforme a operação (Inserção, Alteração ou Navegação). Sem segredos nénom? Qualquer dúvida, deixe seu comentário.
Ufa, calma que já estamos quase concluindo nosso projeto por completo, daqui sete artigos chegaremos ao fim (kkkkkkkkkk) brincadeira, faltam poucos artigos. Brincadeiras a parte, agora vamos implementar o evento "OnClick" do botão "btnCliente". Este botão, está no formulário do menu principal, então, acesse ele, dê um duplo-clique sobre o botão "Cliente" e implemente desta forma:

Este botão simplesmente cria o formulário de cadastro de cliente na memória e exibe para o usuário, e quando for fechado, o mesmo é liberado da memória. É importante ressaltar que, você precisa fazer o formulário principal enxergar o formulário de cadastro, para isso, pressione "Alt + F11" e selecione o formulário de cadastro de cliente na lista, deixe a opção "Implementation" marcada e clique no botão "OK". É o famoso "Use Unit". Para finalizarmos este artigo, volte para o formulário de cadastro de cliente, selecione a "StringGrid" e implemente o evento "OnSelectCell" da seguinte maneira:

Conforme o usuário seleciona um registro na "StringGrid", o código do mesmo é armazenado no campo "IdSelecionado", conforme você observou durante as implementações, este campo é usado durante as chamadas de alguns métodos, como o método "CarregarCliente" por exemplo.
Gente boa, assim terminamos mais um artigo, esperamos vocês no próximo artigo, um dos últimos desta série espetacular. Até lá. Tchauuu brigadoooo.

Este artigo faz parte da série: CRUD Delphi POO + MVC + DAO;

(Por ClipaTec Informática)

Cadastro Delphi POO + MVC + DAO - Camada View - Parte 4

2018-05-10T13:06:00.000-03:00

Salve, salve galera. De volta a nossa série, no artigo anterior havíamos implementado alguns métodos, neste artigo, daremos continuidade nas implementações dos métodos. Para tal, abra o projeto no Delphi e implemente o método "CarregarCliente" da seguinte forma:

Nas linhas 157 e 158 declaramos nossos objetos da classe TCliente e TClienteController.
Nas linhas 160 e 161 criamos as instâncias desses objetos na memória e nas linhas 176 e 177 liberamos da memória após o uso.
Na linha 163, invocamos o método "CarregarCliente" da classe TClienteController, que por sua vez, vai chamar o método "CarregarCliente" da DAO. Note que este método pede um objeto do tipo TCliente que será preenchido lá na camada DAO, e o código do cliente, cujas informações serão buscadas na base de dados para preencher o objeto.
Da linha 164 a 174, apenas estamos lendo as informações que estão no objeto "oCliente" que foi preenchido anteriormente, e jogando nos componentes da tela, para que o usuário possa ver essas informações.
Agora, vamos implementar o método "Alterar:

Este método, conforme observado, vai ler as informações que estão nos componentes da tela que foram preenchidos pelo usuário e alimenta o objeto com estas informações. Feito isso, este objeto preenchido é passado para o método "Alterar" da "TClienteController", que vai direcionar para a DAO, onde as alterações serão persistida na base de dados, caso ocorra algum erro, o mesmo é retornado pelo método através do parâmetro do tipo variável "sErro", que é exibido pela exceção (raise Exception).
Agora, o método "Listar":

Este método simplesmente ativa a aba de pesquisa.
Implemente o método "Excluir":

Clique na imagem para ampliar e vê-la completo

O método excluir também é bem simples. Na linha 196, estamos verificando se nossa "StringGrid" possui algum registro, caso contrário, uma exceção é suscitada informando que a tabela está vazia, portanto, não há o que excluir.
Caso tenha algum registro selecionado, capturamos o código dele e repassamos para o método "Excluir" da "TClienteController" que fara o resto, como você já sabe.
Após a exclusão, apenas chamamos o método de pesquisa novamente, para atualizar a "StringGrid", se isso não for feito, embora o registro seja excluído ele continuará listado na tabela, e isso pode causar uma dúvida ao usuário, que vai pensar que o registro não foi excluído.
Muito bem, assim chegamos ao final de mais um artigo, aguardamos você no próximo para darmos continuidade, já estamos quase no final desta série, continue conosco, um grande abraço.

Este artigo faz parte da série: CRUD Delphi + POO + MVC + DAO;

(Por ClipaTec Informática)

Cadastro Delphi POO + MVC + DAO - Camada View - Parte 3

2018-03-14T17:27:00.001-03:00

Olá meu povo, no artigo anterior nós implementamos a camada Controller, e neste artigo, vamos retornar a nossa camada VIEW, só que desta vez, vamos iniciar a implementação dos métodos.

Para, isso, com o projeto aberto no Delphi, acesse o "FrmCadastrarCliente", e no código, logo acima da classe do formulário, vamos criar um tipo enumerado chamada "TOperacao" que utilizaremos como flag para habilitar e desabilitar controles e para nortear o botão "Gravar", então, declare-o logo acima da classe do formulário:

Muito bem, feito isso, agora precisamos criar um atributo na classe do formulário que armazene o valor deste tipo enumerado que utilizaremos em determinados momentos durante a execução do aplicativo. No Delphi, os atributos de uma classe são chamados de "Fields", por isso, por convenção, o nome de um "Field" sempre inicia com a letra "F", então, vamos criar dois "Fields", um para armazenar o valor do tipo enumerado "FOperacao" e outro para guardar o código do cliente que for selecionado na Grid de pesquisa "FIdSelecionado", tudo isso na seção "Private". Também, aproveitando o momento, vamos declarar nossos métodos, a implementação completa ficará assim:

Pressione a tecla de atalho "Shift + Ctrl + C" e vamos iniciar implementando o método "SetUp":

Este método será chamado assim que a tela de cadastro for aberta, desta maneira, conforme a implementação acima, ele oculta a visibilidade das abas, ativa por padrão a aba de pesquisa, e define o código "1" por padrão ao nosso Field "IdSelecionado".

Agora vamos implementar o nosso método "Pesquisar":

Como já deve estar bem claro na sua mente, os métodos estão na camada DAO, portanto, para que a VIEW possa consumi-los, isto é, ter acesso a eles, isso é feito por intermédio da camada Controller, então, nós precisamos criar um objeto do tipo "TClienteController" para que por meio deste objeto, tenhamos acesso ao método da DAO, pois a Controller consegue enxergá-la.

Na linha 307 declaramos nosso objeto com seu tipo, na linha 309 instanciamos ele na memória. Na linha 311, chamamos o método "Pesquisar" que pede dois parâmetros, o primeiro, o filtro da pesquisa, que é por "Nome", desta maneira, passamos o conteúdo digitado pelo usuário no "edtPesquisar", o segundo parâmetro, é a nossa "TStringGrid" da aba de pesquisa, pois a mesma será configurada e preenchida lá na camada DAO. Por fim, na linha 313 apenas liberamos o objeto da memória após sua utilização.

Agora vamos implementar o método "Novo":

Este método é bem simples, ele apenas define o valor do nosso field "FOperacao" para "opNovo" e ativa a aba de dados. Este método será chamada quando o usuário clicar no botão "Novo". Você vai entender melhor porque estamos definindo o valor "opNovo" para o Field quando estivermos implementando o botão "Gravar".

Seguindo, agora implementaremos o método "Detalhar":

Este método verifica o cliente que está selecionado na pesquisa, captura o código dele, consulta ele no banco de dados, busca todas as informações por meio do método "CarregarCliente", e em seguida, ativa a aba de dados com estas informações preenchidas nos controles. Mas note que antes, na linha 183, fazemos uma pequena verificação, se na coluna 0 e linha 1 da Grid, se existe alguma informação, caso não exista informação, significa que a pesquisa não retornou nada, então, abortamos a operação de detalhamento e emitimos uma mensagem para o usuário.

Legal, no próximo artigo, seguiremos com a implementação dos métodos, vamos ficando por aqui, qualquer dúvida, deixe seu comentário, um forte Abraço. Tchau!

Este artigo faz parte da série: CRUD Delphi POO + MVC + DAO;

(Por ClipaTec Informática)

Cadastro Delphi POO + MVC + DAO - Camada Controller

2018-03-03T09:00:00.000-03:00

Oi, tudo bem com vocês? Estamos quase acabando nossa série por completo. No artigo de hoje, iremos implementar a camada Controller que é bem simples.

Sem delongas, com o projeto aberto no Delphi, crie uma nova unit e salve com o nome "uClienteController" dentro da pasta "controller".

Vamos precisar criar uma classe "TClienteController" com seus métodos, segue a implementação (não esqueça das uses):

Agora, pressione a tecla de atalho "Shift + Ctrl + C" e implemente os métodos da seguinte maneira:

Note que criamos os métodos exatamente iguais a camada DAO em sua assinatura, pois como você já sabe, a camada Controller, vai ser apenas uma intermediária entre a View e DAO, ela é responsável por definir o fluxo de dados, de onde vem e para onde vai, sendo assim, ela apenas chama os métodos da DAO, repassando os mesmos parâmetros, e após a execução dos métodos na DAO, ela captura o retorno e envia para quem está chamando o método, neste caso, será a View.

Pronto, acabou. Mas já? Só isso? Tem certeza? Simmmm. Acabou hehehe. Então isso é um tchau, até o próximo artigo, onde retornaremos a camada View, só que agora, para implementar os métodos, visto que nas parte 1 e parte 2 da View já publicados apenas criamos o layout da tela de CRUD Cliente. Até lá, abraço.

Este artigo faz parte da série CRUD Delphi POO + MVC + DAO;

(Por ClipaTec Informática)

Cadastro Delphi POO + MVC + DAO - Camada DAO - Parte 5

2018-03-02T06:00:00.000-03:00

Fala gente boa, no artigo de hoje, concluiremos finalmente a camada DAO Cliente. No artigo anterior, implementamos os métodos "CarregarCliente" e "Inserir". Neste artigo, iremos implementar os métodos "Alterar" e "Excluir", finalizando esta camada.

O método "Alterar" é muito semelhante ao método "Inserir" em sua estrutura, o que muda, é apenas a instrução SQL que está inserida no componente "sqlAlterar":

Da linha 41 a 49 estamos lendo as propriedades do objeto "oCliente" passado por parâmetro, recuperando seus valores e atribuindo aos parâmetros do SQL. Na linha 51 tentamos persistir estas alterações no banco, se não houver falha, na linha 52 retornamos True, caso contrário, cairá no bloco de exceção, onde capturamos o erro e atribuímos ao parâmetro varável "sErro" e retornamos False.

Qualquer dúvida em relação ao entendimento dos códigos, deixe seu comentário para que possamos ajudá-lo.

Agora vamos implementar o método "Excluir":

Este método é o mais simples, porque, para excluirmos um determinado cliente, apenas precisamos saber qual é o código dele, então o método pede por parâmetro o código do cliente a ser excluído, este valor é alimentado na instrução SQL de "delete" conforme a linha 93, o restante do método, dispensa comentários, visto que é a mesma coisa dos métodos anteriores.

Muito bem, finalmente e felizmente concluímos a camada DAO Cliente. No próximo artigo, vamos dar inicio na implementação da camada "Controller".

É importante observar, que não estamos exibindo nenhuma mensagem dentro da camada DAO, pois, as mensagens estão sendo repassados por meio de um parâmetro de saída, que é uma variável, esta mensagem é retornada para a camada Controller que vai retornar para a camada View que finalmente, irá exibir na tela para o usuário. Simples assim.
Antes de encerrarmos este artigo, precisamos definir que tanto a tela de cadastro de cliente quanto o Data Module de cliente, sejam criados no momento em que formos utilizá-los, ou seja, eles não serão criados automaticamente na memória assim que a aplicação for iniciada. Para isso, clique no menu "Project/Options", clique no item "Forms" listado ao lado esquerdo, selecione o "DmCliente" e "FrmCadastrarCliente", em seguida, clique no botão com o símbolo ">" para incluí-los na lista de "Available Forms". Clique no botão "OK" e pronto, agora, eles não serão mais criados automaticamente assim que a aplicação for iniciada, iremos criá-los e destruí-los em tempo de execução, no momento em que precisarmos.

Clique na imagem para ampliar o tamanho.

Até o próximo artigo, abraço, beijo me liga.

Este artigo faz parte da série Cadastro Delphi POO + MVC + DAO;

(Por ClipaTec Informática)

Dados e Informação, qual a diferença?

2018-03-01T07:30:00.000-03:00

É comum ouvirmos a seguinte frase quando estamos em um curso da área de T.I. acerca de processamento de dados: "no computador existe a entrada, processamento e saída", até aqui tudo bem, porém, vem o erro: "entra dados, processa-se dados e sai dados". É trivial ouvirmos esta última parte até mesmo por parte de alguns instrutores/professores.

Em sistema de informação, é necessário que estes dois conceitos (dados e informação) estejam muito bem definidos, é de grande importância saber a diferença entre um e outro. Então, qual a diferença entre dados e informação?

Antes de começar a explicar a diferença entre um e outro, é importante salientar que, ambos os conceitos, são fundamentais para a construção do conhecimento, visto que, um conhecimento nada mais é que, o resultado de dados que foram analisados e se tornaram uma informação, ou seja, são etapas que precedem o conhecimento. Vamos citar alguns exemplos após a definição dos conceitos para que você possa assimilar melhor.

1. Dados

Os dados representam um conjunto/sequencia de fatos que ainda não foram analisados, ou seja, são puramente simples observações sobre o ambiente (organização, seja privada, governamental, filantrópica, etc).

Para se tornar uma informação, eles precisam ser analisados, relacionados ou interpretados e organizados de uma forma compreensível e contextualizados, isto é, com um sentido ou significado.

Exemplo 1:

Exemplo 2:

"Laranja"

Exemplo 3:

"23", "ClipaTec", "produção", "19:30"

Agora me diga, você entendeu alguma coisa? Obviamente que não, estes três exemplos, apresentam dados, mas não sabemos o que significa, pois, ainda não foram analisados e contextualizados, ou seja, estão totalmente sem sentido algum. Veremos adiante o entendimento destes dados.

2. Informação

A informação nada mais é que, a apresentação organizada e arranjada dos dados de forma útil e compreensível,isto é, com significado. Com isso, podemos obter previsões de atividades e resultados futuros de uma organização, o que chamamos de conhecimento, a partir disso, o administrador pode tomar decisões.

Agora, vamos processar os três exemplos citados no tópico "Dados" acima:

Exemplo 1:

Opa, agora todos aqueles dados fazem algum sentido, certo? Isso é possível porque, os dados agora estão organizados e estão apresentados a nós de maneira compreensível. Mediante isso, temos o conhecimento de que se trata de informações referentes a uma determinada pessoa.

Exemplo 2:

"A camiseta que o Welinton estava usando era de cor laranja."

Legal, quando tínhamos apenas o dado "laranja", poderíamos até arriscar em deduzir o que seria, alguém poderia dizer que se referia a fruta, outro poderia dizer que se referia a cor, quem está certo? Não daria para criar uma afirmativa, pois, o conhecimento só será obtido através do processamento deste dado. Entra aqui, a questão da abstração, que rasamento falando, é a capacidade de analisar e coletar informações do mundo real, o dado é o menor nível de abstração, enquanto a informação é um nível maior de abstração, sendo assim, chegamos ao verdadeiro sentido deste dado, que no caso, estava se referindo a "cor" e não a "fruta".

Exemplo 3:

"No dia 23, de agosto, haverá uma reunião com todos os integrantes da equipe ClipaTec Informática, as 19:30, onde será tratado o assunto referente a produção de conteúdo no blog."

Top né? Os dados que foram apresentados no tópico anterior, estão destacados em negrito, repare que, anteriormente não faziam o menor sentido, agora, já é possível termos um entendimento do que se trata.

Os exemplos citados, são bem simples, mas tenho convicção que você conseguiu compreender completamente a diferença entre esses dois conceitos.

Agora, a frase de Goldratt (1985) faz sentido: "Existem dados, mas faltam informações.", correto? É importante que estes dois conceitos estejam bem claros na sua mente.

Mediante a tudo isso, começou a surgir, a necessidade da segurança da informação (que é um assunto que pretendo falar em outro artigo), pois, dentro de uma organização, a informação é muito valiosa.

3. Conclusão

Podemos concluir então, dizendo que, os dados não possuem significado relevante, não levam a nenhuma compreensão a princípio, mas a partir do processamento, ou seja, da análise e organização, gera uma informação contextualizada, que nos leva a uma compreensão melhor, e partir disso, obtemos um conhecimento.

Agora vou deixar vocês com muito desejo, mas a imagem abaixo vai facilitar ainda mais sua compreensão:

Corrigindo então, a frase dita no início do artigo, o correto é: entra dados, processa-se dados e sai informação. Se você leu este artigo até o final, nunca mais você pode errar isso.

A pirâmide abaixo, resume muito bem tudo isso que falamos neste artigo:

Bom, espero que você tenha tido um ótimo aproveitamento, caso ainda tenha dúvida, deixe seu comentário, um grande abraço até o próximo.

(Por Welinton J. Dias)

Cadastro Delphi POO + MVC + DAO - Camada DAO - Parte 4

2018-02-28T05:30:00.000-03:00

Salve, salve galeraaaaa. Estamos de volta nesta saga, e neste artigo iremos continuar a implementação da camada DAO Cliente. Sem perca de tempo, com o projeto aberto no Delphi, vamos dar continuidade. No artigo anterior, implementamos os métodos "GerarID" e "Pesquisar". Seguindo a ordem das declarações, agora vamos implementar o método "CarregarCliente". Segue a implementação:

Na linha 64 estamos declarando uma variável de instância do tipo TSQLDataSet para que possamos executar nossa instrução SQL. Estamos mostrando as duas formas para que você possa optar por qual usar, seja adicionando o componente diretamente no Data Module ou criando em tempo de execução.

Na linha 66 criamos ele na memória, na linha 68 conectamos o componente com o banco de dados, visto que, esta conexão está encapsulada no componente "sqlConexao" que por sua vez, está dentro do Data Module "DmConexao". Da linha 69 a 71, estamos atribuindo ao componente, nossa instrução SQL, alimentando o parâmetro do SQL com o parâmetro passado pelo método. Como vocês observaram, este método pede o parâmetro "oCliente" do tipo "TCliente", ou seja, um objeto "Cliente" será passado por parâmetro e o método vai alimentar os atributos deste objeto com os valores que serão recuperado do banco de dados através da instrução SQL. Então, na instrução SQL, estamos buscando todas as informações referentes ao cliente cujo código foi passado pelo parâmetro "iCodigo".

Se você observar, está ocorrendo um erro no tipo "TCliente", isso ocorre porque precisamos dar uses em nossa camada Cliente Model, pois a classe TCliente está declarada nela, então, pressione "Alt + F11" e selecione a unit "uClienteModel", deixe marcado a opção "Interface" e dê "OK".

Legal, agora o erro no tipo TCliente sumiu. Continuando a explicação do método, da linha 75 a 82, estamos recuperando a informação retornada do SQL e atribuindo para as propriedades do objeto. Na linha 85, apenas liberamos o objeto TSQLDataSet da memória.

Repare que o objeto "oCliente" não foi instanciado, porque o mesmo já vai estar criado em outra camada, então, este parâmetro representa o objeto já criado, apenas estamos alimentando as propriedades dele com as devidas informações retornadas pela execução do SQL.

Agora vamos implementar o método "Inserir":

Este método, também pede um parâmetro do tipo "TCliente", que nada mais é que o objeto já criado contendo informações, onde estas informações serão lidas e gravadas no banco de dados. O segundo parâmetro, é um parâmetro de saída, isso significa que, após a execução do método, este parâmetro irá conter uma informação, é importante ressaltar que parâmetros do tipo "var" e "out", podemos dizer que é um container para uma varável que já existe do outro lado, de onde está sendo chamado este método. Vamos entender melhor isso nas implementações dos métodos da camada "view".

Na linha 126, estamos usando o componente "sqlInserir" que está no "DmCliente" que já está configurado com a instrução SQL que fizemos na parte 2, e também estamos usando o objeto "oCliente" passado por parâmetro.

Na linha 128, estamos alimentando o primeiro parâmetro do SQL, que é o campo "ID" existente na tabela "Cliente" do banco de dados. Note que estamos chamando o método "GerarID", que como vimos, irá gerar o código sequencial e retorná-lo para quem está chamando.

Da linha 129 a 132, estamos fazendo uma pequena verificação, caso o código da cidade seja zero, anulamos o parâmetro, para não ocorrer erro de chave estrangeira, pois a cidade cujo código é zero não existe na tabela "Cidade" do banco.

Resumindo, da linha 128 a 136 estamos alimentando os parâmetros do SQL de Insert com as informações do objeto Cliente. Na linha 138 tentamos persistir esses dados no banco, se nenhuma exceção for levantada, a função retorna True, ou seja, verdadeiro, deu tudo certo, caso contrário, cairá na exceção, a mensagem de erro será capturada pelo bloco "except" na linha 142, e a função, retornará False, ou seja, Falso, deu algo errado.

Muito bem galera, vamos parando por aqui, no próximo artigo, vamos concluir a implementação da camada DAO Cliente. Até lá, abraço.

Este artigo faz parte da série Cadastro em Delphi POO + MVC + DAO;

(Por ClipaTec Informática)

Delphi: Métodos e Parâmetros

2018-02-27T10:11:00.002-03:00

Métodos

Um software, resumidamente falando, nada mais é que um aglomerado de instruções que quando executadas, apresentam a solução para um determinado problema que está sendo processado. Digamos que o problema seja informatizar uma fixa de cadastro de cliente, o software irá fornecer meios para capturar tais dados, que serão processados e armazenados de forma inteligente e organizada, sendo possíveis serem recuperados com facilidade posteriormente.

As linguagens de programação, oferecem meios para gerar estas instruções, é o que chamamos de métodos ou rotinas. Os métodos nada mais são que as instruções que compõem um sistema.

Basicamente, existem dois tipos de métodos, aquele que processa os dados e gera um retorno deste processamento, para que este retorno seja utilizado para outra finalidade, por exemplo, um determinado método calcula um desconto que foi aplicado em uma venda por meio de uma porcentagem, e retorna este valor para ser subtraído do valor total da venda, então note que neste caso, o método devolveu um valor, que foi utilizado em outro método, o método que calcularia o valor final a ser pago pelo cliente.

Existe também, o método que não gera um retorno, ele simplesmente processa os dados e não há a necessidade de gerar um retorno.

Cada linguagem tem sua forma de diferenciar estes dois tipos de métodos, isto é, o que retorna e o que não retorna. No Java, estes métodos são diferenciados pela presença ou ausência da palavra "void" na assinatura do método. Quando um método é void, significa que ele não retorna nenhuma informação, caso contrário, o método gera um retorno.

No Delphi, a diferenciação entre estes métodos, está nas palavras "function" e "procedure". Ao declarar um método no Delphi, em sua assinatura, esta especificação é o primeiro elemento, ou seja, é necessário definir primeiramente se o método retorna alguma informação "function" ou não "procedure". Exemplo:

procedure ConfigurarPerfilUsuario;

No exemplo acima, temos um método que não retorna nenhuma informação, sabemos disso porque ele inicia com a palavra "procedure", logo, uma procedure, é um método que não retorna informação. Agora veja o seguinte exemplo:

function GravarCliente: Boolean;

Já neste caso, temos um método que retorna alguma informação, pois, ele inicia com a palavra "function", logo, uma function, é um método que retorna uma informação.

No Java, um método que retorna informação, este retorno é definido pelo comando "return", já no Delphi, pelo comando "Result". Obrigatoriamente, o valor a ser retornado, deve ser do mesmo tipo indicado na assinatura do método. Ainda utilizando o exemplo acima da function "GravarCliente", note que em sua assinatura, estamos dizendo que o retorno dela é do tipo booleano (Boolean) (True/False - Verdadeiro/Falso). No Delphi, o tipo de retorno é o último elemento na assinatura do método.

Parâmetros

As vezes, para que os dados sejam processados, os métodos precisam de alguns valores de entrada, estes valores são passados no momento em que chamamos o método.

Na assinatura de um método, podemos definir o que chamamos de parâmetros, podendo ser um ou vários. Exemplo:

procedure AplicarCreditoCliente(iCodigoCliente: Integer; nValorCredito: Real);

No exemplo acima, temos um método que vai adicionar a um determinado cliente um valor de crédito, então, eu preciso dizer quem é este cliente e qual o valor do crédito, então, passamos para o método estes dois valores de entrada para que o processamento seja realizado. Então, temos um método com dois parâmetros.

No Delphi, um parâmetro deve ter nome seguido do tipo de dados que o mesmo vai receber:

procedure CalcularIdade(dDataNascimento: TDate);

No exemplo acima, temos um parâmetro chamado "dDataNascimento", e seu tipo é "TDate", ou seja, é necessário passar um valor de entrada do tipo data como parâmetro para o método.

Quando temos mais de um parâmetro, separamos por ";" (ponto e vírgula), todos os parâmetros devem ter nome seguido do tipo, como vimos no exemplo acima do método "AplicarCreditoCliente". Exemplo:

procedure NomeDoMetodo(sParametro1: string; iParametro2: Integer; nParametro3:Real);

Quando temos mais de um parâmetro do mesmo tipo, podemos separá-los por "," (vírgula), definindo o tipo após o último, exemplo:

function AlterarLancamento(iCodigo: Integer; nValor, nMulta, nJuros: Real): Boolean;

Os parâmetros "nValor, nMulta e nJuros", por serem do mesmo tipo, foram separados por "," e somente após o último foi definido o tipo deles, mas, nada impede de você passar o tipo para cada um separadamente:

function AlterarLancamento(iCodigo: Integer; nValor: Real; nMulta: Real; nJuros: Real): Boolean;

Podemos também, definir um valor padrão para um parâmetro, caso o mesmo não seja passado no momento em que for chamado. Mas deve-se tomar muito cuidado com isso, este tipo de parâmetro se torna opcional e deve ser o último na assinatura do método, e no máximo um. Exemplo:

procedure GerarChaveLiberacaoSistema(iCodigoCliente: Integer; bMensal: Boolean = True);

Note que o último parâmetro "bMensal" já possui um valor padrão definido no método, sendo este, True, ou seja, este parâmetro agora é opcional, então, no momento em que o mesmo for chamado, o compilador Delphi não vai obrigar passar um valor de entrada para ele, pois, caso não exista este valor, ele assumirá o valor True por padrão.

Conclusão

Todo software é composto por métodos, que são declarações em blocos independentes, que podem ser chamados a partir de locais diferentes. Os métodos são capazes de processar dados, tomar decisões, gerar resultados com a finalidade de solucionar os problemas propostos. Existem métodos que dentro deles, fazem chamadas a outros métodos que também fazem chamadas a outros, e assim sucessivamente, formando um aninhamento de métodos. Também, existem métodos recursivos, ou seja, que chamam a si mesmos em determinadas situações. Existem parâmetros variáveis e constantes, mas tudo isso serão assuntos para um outro artigo, meu objetivo aqui, foi apenas dar uma introdução no conceito de método principalmente usando o Delphi como linguagem de programação. Até o próximo, um grande abraço.

(Por Welinton J. Dias)

Cadastro Delphi POO + MVC + DAO - Camada DAO - Parte 3

2018-02-24T06:00:00.000-03:00

Aôô meu povo, tudo bem com vocês? No artigo anterior, implementamos nossas instruções SQL, agora vamos começar a implementar os métodos da camada DAO.

Legal, com o projeto aberto no Delphi, vamos para o "DmCliente", e declare os seguintes métodos dentro da seção "public":

Pressione a tecla de atalho "Shift + Ctrl + C" para que os métodos sejam declarados na seção "Implementation" da "Unit". Vá até a declaração do método "GerarID" e vamos implementá-lo.

O método "GerarID" simplesmente é responsável por gerar o código sequencial (chave primária) do cadastro de cliente, implemente-o da seguinte forma:

Na linha 108, estamos declarando um objeto/variável do tipo "TSQLDataSet". Este objeto será um componente do tipo TSQLDataSet, que utilizaremos para executar nossa instrução SQL em tempo de execução, logo após o seu uso, descartamos da memória.

Na linha 110, estamos criando este objeto na memória, na linha 114 conectamos ele ao nosso banco que está encapsulado no componente "sqlConexao" que está dentro do Data Module "DmConexao", para isso, pressione as teclas "Alt + F11", na lista que aparecer, selecione o "DmCliente", deixa a opção "Interface" marcada e dê "OK" para darmos "uses" nele dentro do "DmCliente". Agora conseguimos referenciar o componente "sqlConexao" sem erros.

Na linha 115 passamos nossa instrução SQL que está buscando o código do último registro e incrementando um a este código, desta forma, obtemos o número de sequência para o novo registro que estará sendo cadastrado. Na linha 116 abrimos o DataSet e na linha 117 retornamos este código sequencial pra quem chamou este método. Note que o tipo de retorno deste método é "Integer (Inteiro)".

Por fim, a linha 120 apenas está liberando o objeto que criamos anteriormente da memória.

O próximo método a ser implementado, é o método "Pesquisar". Note que este método pede dois parâmetros, o "sNome" que será o nome do cliente a ser pesquisado na base de dados e o "aStringGrid" que é o componente "TStringGrid" que vai mostrar o resultado desta pesquisa em forma de tabela visualmente para o cliente lá na aba de pesquisa do formulário de cadastro.

Segue sua implementação:

Para configurar o componente Grid, precisamos definir as colunas e linhas que receberão os valores providos pelo resultado da execução da instrução SQ, para configurarmos as linhas da nossa Grid, vamos criar uma variável chamada "iTotal" do tipo "Inteiro", é exatamente isso que está sendo feito na linha 151. Na linha 154 inicializamos o valor desta variável com um, garantindo que teremos pelo menos uma linha na Grid. A quantidade de linhas a ser configurada, deve ser exatamente a mesma quantidade de registros retornados pelo SQL, caso contrário alguns registros podem não aparecer, se caso a quantidade de linha for menor que a quantidade de registros retornados, por isso, vamos criando as linhas conforme percorremos os registros. Da linha 157 a 162 estamos apenas alimentando o parâmetro "nome" da instrução SQL atribuída ao componente "sqlPesquisar" conforme fizemos no artigo anterior desta série. Da linha 166 a 178 estamos configurando as colunas da Grid, com seus títulos e tamanhos.

Agora, da linha 180 a 191 estamos atribuindo ao objeto Grid os registros retornados do SQL.

Não vamos explicar todos os comandos porque já é do conhecimento de vocês, mas, caso tenham alguma dúvida sobre algum comando ou implementação, deixe seu comentário que explicaremos a você.

Vamos ficando por aqui. No próximo artigo seguiremos implementando nossa camada DAO Cliente. Até lá, abraço.

Este artigo faz parte da série de Cadastro em Delphi POO + MVC + DAO;

(Por ClipaTec Informática)

Delphi: Escopo de Classe

2018-02-23T11:35:00.001-03:00

Salve, salve! Quem disse que o Delphi não da suporte a programação orientada a objetos? Quem diz isso, certamente não o conhece direito. Neste artigo vamos falar sobre a visibilidade de um objeto (instância da classe).

As definições de visibilidade nas classes Delphi é importante, e devem ser configuradas com cuidado. Através destas definições determinamos se os elementos da classe (atributos, métodos, etc) é visível ou não.

No Delphi temos os seguintes escopos de visibilidade do mais restritivo ao menos restritivo: strict private, private, strict protected, protected, public e published.

Quando vamos criar nossas classes no Delphi, estas implementações são feitas dentro de uma unit, e na mesma unit você pode ter uma ou várias classes, e também podemos implementar classes em outra(s) unit(s), e as vezes, determinados atributos e/ou métodos de uma classe devem/podem ser acessador por outras já outros atributos e/ou métodos não podem, e ainda, talvez a restrição seja apenas para as classes que não são descendentes, e por ai vai. Isso tudo vai ficar mais claro a medida em que formos explicando.

Antes de falar da visibilidade strict private e strict protected, precisamos entender que no Delphi temos o conceito de classes amigas, o que é isso? Quando mais de uma classe é criada na mesma unit, elas são consideradas amigas, sendo assim, mesmo que um atributo ou método esteja declarado dentro da seção "private" ou "protected" de uma classe, todas as classes que estão presentes na mesma unit terão acesso a eles, ou seja, em tese, um atributo ou método declarado em private somente é acessado somente pela própria classe e um atributo ou método declarado em protected somente é acessado pela própria classe e suas descendentes, porém, com este conceito de classes amigas, as demais classes conseguem ter acesso, exceto as classes que estão em outra unit, isto é, as inimigas, beijo kkkkk (só pra descontrair).

Aí você talvez esteja pensando, mas pra que toda esta explicação antes de falar do escopo de visibilidade strict private e strict protected? Tudo! Exatamente por isso meus caros, quando eu tenho mais de uma classe dentro da mesma unit, e não quero que as classes amigas tenham acesso aos atributos e métodos privados ou protegidos, então basta declarar o atributo ou método dentro do escopo strict private, desta maneira, somente a própria classe terá acesso a eles, ou strict protected, onde somente a própria classe e filhas terão acesso, ou seja, as classes amigas não conseguirão mais acessa-los. Tomem muito cuidado com esses escopos, nós defendemos a ideia de que cada classe esteja implementada em uma unit, porém, se quiser ter mais de uma classe na mesma unit, e quiser garantir a privacidade de um atributo ou método somente a própria classe e as descendentes, deve-se usar o escopo "strict private" ao invés de "private" ou "strict protected" ao invés de "protected".

Ufa, parece um tanto confuso entender tudo isso, mas vamos entender os demais escopos, isso vai ajudar a entender melhor.

Privado (private)

Como já foi explicado anteriormente, os atributos e métodos declarados dentro desta seção só podem ser acessados pela própria classe e pelas classes amigas, portanto, as classes que estão em outras units (inimigas) não conseguem ter acesso.

Protegido (protected)

Os atributos e métodos declarados neste escopo, podem ser acessados pela própria classe, classes descendentes (filhas) e pelas classes amigas.

Público (public)

Neste escopo, qualquer classe podem acessar os atributos e métodos, ou seja, todas, seja amiga, seja inimiga, filha ou não.

Publicado (published)

É igual ao escopo public, porém, pode também ser acessado via RTTI, um exemplo disso, é quando conseguimos acessar os atributos e métodos pelo Object Inspector de um determinado objeto, como um "TEdit" por exemplo.

Nas versões novas do Delphi onde foram feitas modificações na RTTI, este escopo perde um pouco o sentido, visto que, com as novas modificações, já é possível ter acesso aos atributos e métodos dos outros escopos também.

Antes de finalizarmos este artigo, existe um escopo pouco falado, o "automated".

Automatizado (automated)

Este escopo é semelhante ao public, com apenas um incremento, onde as informações de tipo automático (automation type information) são geradas, muito utilizadas em classes "Windows". Os "Automation Objects" permitem trabalhar com objetos de aplicações como "Word" por exemplo, ou seja, é pertinente a API OLE Automation.

Muito bem, agora que tudo ficou mais claro, apenas ressaltando:

Estritamente Privado (strict private)

Apenas a própria classe pode ter acesso, as classes amigas, inimigas e filhas não possuem acesso.

Estritamente Protegido (strict protected)

Apenas a própria classe e classes filhas podem ter acesso, as classes amigas e inimigas não possuem acesso.

Assim chegamos ao final deste artigo. Agora que você conhece a diferença entre os escopos de visibilidade, usem com cuidado. Estes escopos são extremamentes importantes quando trabalhamos com criação de componentes por exemplo. Qualquer dúvida, deixe seu comentário, até mais. Abraço.

(Por ClipaTec Informática)

Cadastro Delphi POO + MVC + DAO - Camada DAO - Parte 2

2018-02-22T08:30:00.000-03:00

yupiiii, olá, olá clipatequeiros de plantão, bora dar continuidade nessa série. Neste artigo, vamos continuar implementando a camada DAO. Sem perca de tempo, com o projeto aberto no Delphi, crie um novo "Data Module", defina o "Name = DmCliente" e salve como "uDmCliente" dentro da pasta DAO.

Adicione quatro componentes "TSQLDataSet" e altere a propriedade "Name" de cada um para "sqlPesquisar", "sqlInserir", "sqlAlterar" e "sqlExcluir". Agora adicione um componente "TDataSetProvider", altere a propriedade "Name" para "dspPesquisar" e na propriedade "DataSet" aponte para o componente "sqlPesquisar". Agora adicione um componente "TClientDataSet", altere a propriedade "Name" para "cdsPesquisar" e na propriedade "ProviderName" aponte para o componente "dspPesquisar".

OK, agora, precisamos alimentar os componentes TSQLDataSet com seus respectivos comandos SQL. Então, selecione o componente "sqlPesquisar" e na propriedade "CommandText" adicione a seguinte instrução SQL:

"select c.id, c.nome, c.telefone, cid.nome as cidade from cliente c left join cidade cid on (c.id_cidade = cid.id) where c.nome like :nome"

Agora precisamos configurar o tipo do parâmetro "nome" presente na nossa instrução SQL. Não vamos entrar em detalhes na explicação do SQL, basicamente estamos trazendo algumas informações do banco de dados referente ao cliente, dando opção de pesquisar por nome apenas. Você pode incrementar este SQL adicionando mais opções de pesquisa. Para configurar o parâmetro, clique no botão elíptico (botão com três pontinhos...) da propriedade "Params" do "sqlPesquisar". A janela que lista os parâmetros contidos no SQL será aberta, como só temos um "o nome", então apenas ele aparece. Clique sobre este parâmetro "nome" e na propriedade "DataType" selecione o tipo "ftString". Feito isso, pode fechar esta janela, porque agora nosso componente "sqlPesquisar" já sabe que o parâmetro "nome" é um parâmetro de entrada que receberá um valor do tipo "string (texto)" que será repassado e substituído no comando SQL.

Agora, clique com o botão direito do mouse sobre o componente "cdsPesquisar" e selecione a opção "Fetch Params", apenas para que este componente também tenha conhecimento do parâmetro "nome".

Show de bola, agora, selecione o componente "sqlInserir" e na propriedade "CommandText" dele, adicione a seguinte instrução SQL:

"insert into CLIENTE (ID, ID_CIDADE, NOME, CPF, RG, TELEFONE) values (:ID, ID_CIDADE, :NOME, :CPF, :RG, :TELEFONE)"

Agora, vá na propriedade "Params" para configurarmos o tipo dos parâmetros igual fizemos com o "sqlPesquisar". Segue o tipo de cada parâmetro: "ID = ftInteger; ID_CIDADE = ftInteger; NOME = ftString; CPF = ftString; RG = ftString; TELEFONE = ftString". Após ter configurado todos estes parâmetros, pode fechar a janela.

Selecione o componente "sqlAlterar" e na propriedade "CommandText" adicione o seguinte comando SQL:

"update CLIENTE set ID_CIDADE = :ID_CIDADE, NOME = :NOME, CPF = :CPF, RG = :RG, TELEFONE = :TELEFONE, where (ID = :ID)"

Configure os tipos dos parâmetros conforme fizemos no "sqlInserir". Muito bem, pra finalizarmos, selecione o componente "sqlExcluir" e na propriedade "CommandText" adicione o seguinte comando SQL:

"delete from CLIENTE where (ID = :ID)"

Configure o parâmetro "ID" para "ftInteger".

Ufa, finalmente chegamos ao fim de mais um artigo, no qual, configuramos todas as instruções SQL. No próximo artigo, vamos começar a implementação dos métodos na camada DAO. Esperamos vocês, até lá.

Este artigo faz parte da série Cadastro Delphi POO + MVC + DAO.

(Por ClipaTec Informática)