Estrutura de um Programa ADVPL

 

Um programa de computador nada mais é do que um grupo de comandos logicamente dispostos com o objetivo de executar determinada tarefa. Esses comandos são gravados em um arquivo texto que é transformado em uma linguagem executável por um computador através de um processo chamado compilação. A compilação substitui os comandos de alto nível (que os humanos compreendem) por instruções de baixo nível (compreendida pelo sistema operacional em execução no computador). No caso do ADVPL, não é o sistema operacional de um computador que irá executar o código compilado, mas sim o Protheus Server.

Desenvolvendo aplicações em ADVPL


A Linguagem ADVPL teve seu início em 1994, sendo na verdade uma evolução na utilização de
linguagens no padrão xBase pela Microsiga Software S.A. (Clipper, Visual Objects e depois
FiveWin). Com a criação da tecnologia Protheus, era necessário criar uma linguagem que
suportasse o padrão xBase para a manutenção de todo o código existente do sistema de ERP
Siga Advanced. Foi então criada a linguagem chamada Advanced Protheus Language.
O ADVPL é uma extensão do padrão xBase de comandos e funções, operadores, estruturas de
controle de fluxo e palavras reservadas, contando também com funções e comandos
disponibilizados pela Microsiga que a torna uma linguagem completa para a criação de
aplicações ERP prontas para a Internet. Também é uma linguagem orientada a objetos e
eventos, permitindo ao programador desenvolver aplicações visuais e criar suas próprias
classes de objetos.
Quando compilados, todos os arquivos de código tornam-se unidades de inteligência básicas,
chamados APO´s (de Advanced Protheus Objects). Tais APO´s são mantidos em um
repositório e carregados dinamicamente pelo PROTHEUS Server para a execução. Como não
existe a linkedição, ou união física do código compilado a um determinado módulo ou
aplicação, funções criadas em ADVPL podem ser executadas em qualquer ponto do ambiente

Pedido de Vendas (ExecAuto)


Abrangências:Microsiga Protheus 11 , Protheus 10
Versões:Protheus 10
Compatível Países:Todos
Sistemas Operacionais:Todos
Compatível às Bases de Dados:Todos
Nível de Acesso:Nível 1 (Acesso Clientes)
Idiomas:Português (Brasil)
Descrição:
MATA410 - Geração automática de Pedido de Vendas (ExecAuto) ( [ aCabec ] [ aItens ] [ nOpc ] )

ProtheusXBestsales


Função: MATA030 - Cadastro de Clientes (ExecAuto)
Abrangências:Microsiga Protheus 11 , Protheus 10
Versões:Protheus 10
Compatível Países:Todos
Sistemas Operacionais:Todos
Compatível às Bases de Dados:Todos
Nível de Acesso:Nível 1 (Acesso Clientes)
Idiomas:Português (Brasil)
Descrição:
Função utilizada para inclusão, alteração e exclusão de clientes via rotina automática (ExecAuto).MATA030 - Cadastro de Clientes (ExecAuto) ( [ aVetor ] [ nOpc ] ) --> Nil

Manipulação de Data e Hora







Abaixo segue várias funções para manipulação de Data e Hora.








CDOW()
Função que converte uma data para uma cadeia de caracteres.
Sintaxe: CDOW( dExp )
Parâmetros:
dExp Data que será convertida.
Retorno:
cDayWeek Nome do dia da semana como uma cadeia de caracteres. A primeira letra é
maiúscula e as demais minúsculas.
Exemplo:
Código
1
2
3
4
dData := DATE() // Resultado: 09/01/90
cDiaDaSemana := CDOW(DATE()) // Resultado: Friday
cDiaDaSemana := CDOW(DATE() + 7) // Resultado: Friday
cDiaDaSemana := CDOW(CTOD("06/12/90")) // Resultado: Tuesday
A função FG_CDOW(dExp) retorna o nome do dia da semana de acordo com
o idioma em uso pelo ERP.
<strong>CMONTH()</strong>
Função de conversão de datas que retorna uma cadeia de caracteres com o nome do mês em inglês.
Sintaxe: CMONTH( dData )
Parâmetros:
dData Data que será convertida.
Retorno:
cMonth Retorna o nome do mês em uma cadeia de caracteres. A primeira letra do retorno em maiúscula e o restante do nome, em minúsculas.
Exemplo:
Código
1
2
3
4
cMes := CMONTH(DATE()) // Resultado: September
cMes := CMONTH(DATE() + 45) // Resultado: October
cMes := CMONTH(CTOD("12/01/94")) // Resultado: December
cMes := SUBSTR(CMONTH(DATE()), 1, 3) + STR(DAY(DATE())) // Resultado: Sep 1
DATE()
Função que retorna a data do atual sistema. O formato de saída é controlado pelo comando SET DATE, sendo que o formato padrão é mm/dd/yy.
Sintaxe: DATE()
Parâmetros:
Nenhum .
Retorno:
dData Data do sistema.
Exemplo:
Código
1
2
3
4
5
dData := DATE() // Resultado: 09/01/01
dData := DATE() + 30 // Resultado: 10/01/01
dData := DATE() - 30 // Resultado: 08/02/90
dData := DATE()
cMes := CMONTH(dData) // Resultado: September
DAY()
Função de conversão de datas usada para converter o valor data em um número inteiro que representa o dia do mês. Esta função pode ser usada em conjunto com CMONTH() e YEAR() para formatar datas. Pode ser usada também em diversos cálculos envolvendo datas.
Sintaxe: DAY( dData )
Parâmetros:
dData Data que será convertida.
Retorno:
nDias Se o mês do argumento dData for fevereiro, anos bissextos são
considerados. Se a data do argumento dData for 29 de fevereiro e o ano não
for bissexto, ou se o argumento dData for vazio.
Exemplo:
// Estes exemplos mostram a função DAY() de diversas maneiras:
Código
1
2
3
4
5
6
7
8
dData := DATE() // Resultado: 09/01/01
nDia := DAY(DATE()) // Resultado: 1
nDia := DAY(DATE()) + 1 // Resultado: 2
nDia := DAY(CTOD("12/01/94")) // Resultado: 1
// Este exemplo mostra a função DAY() usada em conjunto com CMONTH() e
//YEAR() para formatar o valor da data:
dData := Date()
cData := CMONTH(dData) + STR(DAY(dData)) + "," + STR(YEAR(dData)) // Resultado: June 15, 2001
DOW()
Função que converte uma data para o valor numérico que representa o dia da semana. Útil quando se deseja fazer cálculos semanais. DOW() é similar a CDOW(), que retorna o dia da semana como uma cadeia de caracteres.
Sintaxe: DOW( dData )
Parâmetros:
dData Data que será convertida.
Retorno:
nDia Retorna um número entre zero e sete, representando o dia da semana. O primeiro dia da semana é 1 (Domingo) e o último é 7 (Sábado). Se a data for vazia ou inválida, DOW() retorna zero.
Exemplo:
Código
1
2
3
4
5
dData := DATE() // Resultado: 09/01/01
nDiaDaSemana := DOW(DATE()) // Resultado: 3
cDiaDaSemana := CDOW(DATE()) // Resultado: Tuesday
nDiaDaSemana := DOW(DATE() - 2) // Resultado: 1
cDiaDaSemana := CDOW(DATE() - 2) // Resultado: Sunday
DTOC()
Função para conversão de uma data para uma cadeia de caracteres formatada segundo o padrão corrente, definido pelo comando SET DATE. Se for necessária a utilização de formatação especial, use a função TRANSFORM().
Em expressões de índices de arquivo, use DTOS() no lugar de DTOC() para converter datas para cadeia de caracteres.
Sintaxe: DTOC( dData )
Parâmetros:
dData Data que será convertida.
Retorno:
cData É uma cadeia de caracteres representando o valor da data. O retorno é formatado utilizando-se o formato corrente definido pelo comando SET DATE FORMAT. O formato padrão é mm/dd/yy. Para uma data nula ou inválida, o
retorno será uma cadeia de caracteres com espaços e tamanho igual ao formato atual.
Exemplo:
Código
1
2
3
cData := DATE() // Resultado: 09/01/90
cData := DTOC(DATE()) // Resultado: 09/01/90
cData := "Today is " + DTOC(DATE()) // Resultado: Today is 09/01/90
DTOS()
Função para conversão de uma data que pode ser usada para criar expressões de índice. O resultado é estruturado visando manter a ordem correta do índice (ano, mês, dia).
Sintaxe: DTOS( dData )
Parâmetros:
dData Data que será convertida.
Retorno:
sData Retorna uma cadeia de caracteres com oito byte de tamanho no formato yyyymmdd. Quando dData é nulo ou invalido, DTOS() retorna uma cadeia de caracteres com oito espaços. O valor retornado não é afetado pela
formato da data corrente.
Exemplo:
Código
1
2
3
cData := DATE() // Resultado: 09/01/90
cData := DTOS(DATE()) // Resultado: 19900901
nLen := LEN(DTOS(CTOD(""))) // Resultado: 8
ELAPTIME()
Função que retorna uma cadeia de caracteres contendo a diferença de tempo no formato hh:mm:ss, onde hh é a hora ( 1 a 24 ), mm os minutos e ss os segundos.
Sintaxe: ElapTime( cHoraInicial , cHoraFinal )
Parâmetros:
cHoraInicial Informe a hora inicial no formato hh:mm:ss, onde hh é a hora ( 1 a 24 ), mm os minutos e ss os segundos
CHoraFinal Informe a hora final no formato hh:mm:ss, onde hh é a hora ( 1 a 24 ), mm os minutos e ss os segundos.
Retorno:
Caracter A diferença de tempo no formato hh:mm:ss, onde hh é a hora ( 1 a 24 ), mm os minutos e ss os segundos.
Exemplo:
Código
1
2
cHoraInicio := TIME() // Resultado: 10:00:00
cElapsed := ELAPTIME(TIME(), cHoraInicio)
MONTH()
Função de conversão que extrai da data o valor numérico do mês, semelhante a função que retorna o nome do mês a partir do valor de dData.
Sintaxe: MONTH( dData )
Parâmetros:
dData Data que será convertida.
Retorno:
Numérico >=0 e <=12  Para uma data válida.
0  Se a data for nula ou inválida
Exemplo:
Código
1
2
3
dData := DATE() // Resultado: 09/01/01
nMes := MONTH(DATE()) // Resultado: 9
nMes := MONTH(DATE()) + 1 // Resultado: 10
SECONDS()
Esta função retorna o número de segundos decorridos desde a meia-noite, segundo a hora do sistema. Está relacionada à função TIME() que retorna a hora do sistema como uma cadeia de caracteres no formato hh:mm:ss.
Sintaxe: SECONDS()
Parâmetros:
Nenhum .
Retorno:
Numérico >=0 e <=86399  Retorna a hora do sistema em segundos. O valor numérico representa o número de segundos decorridos desde a meia-noite, baseado no relógio de 24 horas e varia de 0 a 86399.
Exemplo:
Código
1
2
3
4
cHora := TIME() // Resultado: 10:00:00
cSegundos := SECONDS() // Resultado: 36000.00
//Este exemplo usa a função SECONDS() para cronometrar o tempo decorrido:
LOCAL nStart, nElapsed<br />nStart:= SECONDS()
TIME()
Função que retorna a hora do sistema como uma cadeia de caracteres, e que está relacionada com SECONDS(), que retorna o valor inteiro representando o número de segundos desde a meia-noite. SECONDS() é geralmente usada no lugar de TIME() para cálculos.
Sintaxe: TIME()
Parâmetros:
Nenhum .
Retorno:
Caracter A hora do sistema como uma cadeia de caracteres no formato hh:mm:ss onde hh é a hora ( 1 a 24 ), mm os minutos e ss os segundos.
Exemplo:
Código
1
2
3
4
cTime := TIME() // Resultado: 10:37:17
cHora := SUBSTR(cTime, 1, 2) // Resultado: 10
cMinutos := SUBSTR(cTime, 4, 2) // Resultado: 37
cSegundos := SUBSTR(cTime, 7, 2) // Resultado: 17
YEAR()
YEAR() é uma função de conversão de data que extrai o valor numérico do ano. YEAR() é membro de um grupo de funções que retornam valores numéricos de uma data. O grupo inclui DAY() e MONTH() que retornam o dia e o mês como valores numéricos.
Sintaxe: YEAR( dData )
Parâmetros:
dData Data que será convertida.
Retorno:
Numérico Valor numérico do ano da data especificada em dData incluindo os dígitos do século. O valor retornado não é afetado pelos valores especificados pelos comandos SET DATE ou SET CENTURY.
Para uma data inválida ou nula será retornado o valor 0.
Exemplo 01:
Código
1
2
3
dData := DATE() // Resultado: 09/20/01
dAno := YEAR(dData) // Resultado: 2001
dAno := YEAR(dData) + 11 // Resultado: 2012
Exemplo 02:
Código
1
2
3
4
// Este exemplo cria uma função de usuário que usa a função YEAR() para formatar o valor da data:
cData := Mdy(DATE()) // Result: September 20, 1990
FUNCTION Mdy( dDate )
RETURN CMONTH(dDate) + " " + LTRIM(STR(DAY(dDate))) + "," + STR(YEAR(dDate))

Integração Advpl - GMaps via XML

Rdmake cria xml que pode posicionar dados no Google Maps num html.



*-------------------------------------------------------------------------------------------------


#INCLUDE 'protheus.ch'
#INCLUDE "XMLXFUN.CH"

*-------------------------------------------------------------------
* Retorna  CLiente Posicionado no Google Maps via XML
*-------------------------------------------------------------------
User Function MpsCli()
Local cCliente  := ""//_QryChec_->C9_CLIENTE
Local cLoja   := ""//_QryChec_->C9_LOJA                               
Local cEol2   := "&lt;br&gt;"
Local cError    := ""
Local cWarning  := ""
Local oScript
Local nRet       



dbselectarea("SA1")

cString := '<markers> '
While !Eof()

  If  Alltrim(SA1->A1_MUN) == "LINHARES"  .and. ;
 Alltrim(SA1->A1_BAIRRO) == "INTERLAGOS" //SA1->A1_ULTCOM > dDate

   cCodigo  := SA1->A1_COD+"-"+SA1->A1_LOJA
  cNome  := SA1->A1_NOME
  cLogad  := SA1->A1_END
  cEstMun  := SA1->A1_MUN
  cEstado  := SA1->A1_EST
                                      
 cEnd := "http://maps.google.com/maps/geo?q="+Alltrim(cLogad)+'+'+;
 Alltrim(cEstMun)+'+'+Alltrim(cEstado)+"&output=csv&sensor=true_or_false&key=abcdefg"
   
 cEnd := strtran(cEnd, " ", "%20")
    cLatiLonge := HTTPGET(cEnd)
    cEnd1 := '{'+cLatiLonge+'}'
 aMaps := &cEnd1
 
 cString += '<marker lat="'+cValtoChar(aMaps[3])+'" lng="'+cValToChar(aMaps[4])+'" html="Endereco&lt;br&gt;'
 cString += cLogad+'"'+'  label='+'"'+cNome+'"'+' />'
 Endif
 dbskip()
Enddo 

cString += '</markers> '
                                
dbgotop()
 //Gera o Objeto XML ref. ao script
 oScript := XmlParser( cString, "_", @cError, @cWarning )

   SAVE oScript XMLFILE "c:\maps\example.xml"

DEFINE MSDIALOG oMaps FROM 0,0 TO 850,1000 PIXEL TITLE "Consulta Cliente"
 oTIBrowser:= TIBrowser():New(0,0,850,650,"c:\maps\map3.htm",oMaps )
          oButton:= TButton():New(310,0070,"OK",oMaps,{||oMaps:End(),lContinue := .T.},40,10,,,,.T.)     
          oButton:= TButton():New(310,0150,"Cancela",oMaps,{||oMaps:End(),lContinue :=.F.},40,10,,,,.T.)     
          oButton:= TButton():New(310,0190,"Imprimir",oMaps,{||oTIBrowser:Print(),lContinue :=.F.},40,10,,,,.T.)     
          //@ 20, 160 BUTTON oBtnPrint PROMPT "Imprimir" SIZE 50,10 ACTION oTIBrowser:Print() OF oDlg PIXEL
ACTIVATE MSDIALOG oMaps CENTERED

Return

Geomind


GeoMind é uma avançada ferramenta de geoprocessamento que permite uma visualização geográfica de todos os seus clientes, capaz de gerar inúmeras informações de mercado indispensáveis para o melhor gerenciamento do seu negócio. Toda e qualquer informação que sua empresa possua pode ser associada a um ponto geográfico em mapas digitais abrangendo 100% do território nacional. Com esta visão dos dados, é possível fazer um estudo através de uma nova ótica mais poderosa das regiões de atuação dos seus vendedores, melhor definição das rotas e acompanhamento das vendas. O Gestor pode visualizar no mapa informações de seu interesse como: clientes inadimplentes, últimas vendas, ticket médio etc. 

Original_geomind

Como são feitas as análises de informações?

A obtenção dos dados pode ser feita através do SoftSite Mobile®, pois todas as informações coletadas podem ser integradas e analisadas pelo GeoMind. Além disso, outras fontes poderão ser utilizadas e obter dados do ERP, planilhas do Excel, dentre outras possibilidades, serão possíveis devido à grande flexibilidade que o GeoMind dispõe para categorizar as informações a serem visualizadas pelo Gestor. 
Com o objetivo de facilitar essa visualização, o sistema dispõe de diversos ícones para ilustrar quaisquer indicadores de acordo com os critérios definidos pelo Gestor, e ainda possibilita o uso de imagens personalizadas como fotos dos vendedores e logo dos clientes, tornando as análises muito mais significativas.
O SoftSite GeoMind permite que o gestor delimite qualquer área separando-as por cor e gere relatórios específicos dessas áreas com ícones personalizados, podendo inclusive atribuir clientes a rota de um vendedor.
 alt=
Com todas essas possibilidades, é possível ter um maior poder de decisão e uma gerência muito mais precisa, captando todas as informações que você necessita, de forma prática e inovadora.