|
GRUPOS DE DISCUSSÃO PROFISSIONAL
WINDEV, WEBDEV e WINDEV Mobile |
| | | | | |
| Inicio → WINDEV 25 → Manual Completo do SCM do WinDev com HFSQL para Iniciantes |
| Manual Completo do SCM do WinDev com HFSQL para Iniciantes |
| Iniciado por Boller, jul., 11 2025 3:28 AM - Sem resposta |
| |
| | | |
|
| |
Membro registado
4.618 mensagems |
|
| Publicado em julho, 11 2025 - 3:28 AM |
Manual Completo do SCM do WinDev com HFSQL para Iniciantes
Bem-vindo ao Guia Passo a Passo do SCM (Source Code Manager) do WinDev, WebDev e WinDev Mobile, integrado ao banco de dados HFSQL Client/Server. Este manual é voltado para iniciantes que nunca usaram o SCM ou o HFSQL, explicando tudo de forma clara, simples e prática. Vamos cobrir desde a configuração inicial até as operações diárias, usando o material fornecido e referências da playlist do YouTube para reforçar o aprendizado.
📖 O que é o SCM e o HFSQL?
• SCM (Source Code Manager): É o sistema de controle de versões da PCSOFT, usado para gerenciar alterações em projetos do WinDev, WebDev ou WinDev Mobile. Ele ajuda equipes a colaborarem, evita conflitos e mantém um histórico claro de mudanças.
• HFSQL Client/Server: É o banco de dados que armazena o repositório do SCM. Ele guarda todos os arquivos do projeto (janelas, relatórios, classes, etc.) e registra quem alterou o quê e quando.
• Por que usar?: O SCM organiza o trabalho em equipe, permitindo que várias pessoas editem o mesmo projeto sem sobrescrever o trabalho umas das outras. Ele é integrado à interface do WinDev, tornando tudo visual e intuitivo.
Exemplo prático: Imagine que você e seus colegas estão construindo um aplicativo. O SCM é como um caderno compartilhado onde cada um anota suas mudanças, e o HFSQL é o armário onde esse caderno é guardado com segurança.
🚀 Antes de Começar: Pré-requisitos
Antes de configurar o SCM, você precisa de:
1 WinDev, WebDev ou WinDev Mobile instalado: Certifique-se de ter a IDE (ambiente de desenvolvimento) instalada no seu computador.
2 HFSQL Client/Server instalado: Este é o banco de dados que vai armazenar o repositório do SCM. Você pode baixá-lo no site da PCSOFT ou instalá-lo junto com o WinDev.
3 Um projeto WX existente: Pode ser um projeto simples de teste no WinDev, WebDev ou Mobile.
4 Acesso a um servidor: O HFSQL precisa rodar em um servidor (pode ser no seu próprio computador, usando “localhost”, para testes).
5 Permissões de administrador: Para criar e gerenciar a base SCM.
Dica: Se você nunca usou o HFSQL, assista ao vídeo da playlist sobre “Introdução ao HFSQL Client/Server” (procure na sua playlist do YouTube fornecida) para entender como instalá-lo.
🛠️ Passo a Passo para Configurar e Usar o SCM
🛠️ Etapa 1: Criar o Repositório SCM no HFSQL
O repositório é como uma “pasta virtual” onde o WinDev guarda todos os arquivos do projeto e o histórico de alterações.
1 Abra a IDE do WinDev:
◦ Inicie o WinDev, WebDev ou WinDev Mobile.
2 Acesse o menu do SCM:
◦ No topo da IDE, clique em SCM > Manage the SCM database > Create a new SCM database.
3 Configure a conexão com o HFSQL:
◦ Nome da conexão: Escolha um nome, como “SCM_MeuProjeto”.
◦ Endereço do servidor: Se o HFSQL está no seu computador, use “localhost”. Se está em outro servidor, insira o IP (ex.: 192.168.1.100).
◦ Porta: Use a padrão (4900), a menos que tenha alterado.
◦ Nome da base: Dê um nome, como “SCM_MeuProjeto”.
◦ Usuário e senha: Insira as credenciais do HFSQL (geralmente “admin” sem senha para testes iniciais).
4 Crie a base:
◦ Clique em “OK”. O WinDev vai criar automaticamente as tabelas necessárias no HFSQL (como SCM_PROJECT, SCM_ELEMENT, SCM_VERSION, etc.).
◦ Você verá uma mensagem confirmando que o repositório foi criado.
Dica visual: Se você abrir o HFSQL Control Center (ferramenta para gerenciar bancos HFSQL), verá a nova base com várias tabelas começando com “SCM_”.
🛠️ Etapa 2: Adicionar Seu Projeto ao SCM
Agora que o repositório existe, vamos conectar seu projeto a ele.
1 Abra seu projeto:
◦ No WinDev, abra o projeto que você quer gerenciar com o SCM (ex.: um sistema de vendas com arquivo .WDP).
2 Adicione o projeto ao SCM:
◦ Vá em SCM > Add the project to the SCM.
◦ Selecione o repositório que você criou (ex.: “SCM_MeuProjeto”).
◦ Clique em “OK”.
3 O que acontece?:
◦ Todos os arquivos do projeto (janelas, classes, relatórios, etc.) são registrados no repositório com a versão inicial (versão 1).
◦ A partir de agora, o SCM controla quem edita cada elemento.
Dica: Para confirmar, clique com o botão direito em uma janela ou classe no explorador de projetos e veja as opções do SCM, como “Check-out” e “Check-in”.
🛠️ Etapa 3: Entendendo os Elementos Controlados
O SCM organiza os arquivos do projeto por “elementos”. Aqui estão os principais tipos que ele gerencia:
Elemento
Extensão
O que é?
Janelas
.WDW
Telas visuais (ex.: formulários, menus)
Análises
.WDD
Modelagem do banco de dados
Classes
.WDC
Códigos reutilizáveis (programação OOP)
Procedimentos
.WDP
Funções ou rotinas reutilizáveis
Relatórios
.WDE
Documentos como etiquetas e relatórios
Consultas
.WDQ
Queries SQL para buscar dados
Componentes
.WDK
Módulos reutilizáveis entre projetos
Exemplo: Se você criar uma janela de login (.WDW), o SCM vai rastrear todas as alterações feitas nela, como quem adicionou um botão ou mudou o código.
🛠️ Etapa 4: Operações Diárias no SCM
Agora que o projeto está no SCM, vamos aprender as operações básicas para trabalhar no dia a dia.
✅ Fazer Check-Out (Bloquear para Edição)
• O que é?: Bloqueia um elemento (ex.: uma janela) para que só você possa editá-lo.
• Como fazer:
1 No explorador de projetos, clique com o botão direito no elemento (ex.: uma janela .WDW).
2 Escolha SCM > Check-out.
3 O ícone do elemento muda para um lápis ✏️, indicando que está bloqueado para você.
• Por que?: Isso impede que outra pessoa edite o mesmo elemento ao mesmo tempo.
✅ Fazer Check-In (Salvar Alterações)
• O que é?: Envia suas alterações para o repositório e desbloqueia o elemento.
• Como fazer:
1 Após editar o elemento, clique com o botão direito nele.
2 Escolha SCM > Check-in.
3 Escreva um comentário curto e claro (ex.: “Adicionei botão de login”).
4 Clique em “OK”.
• O que acontece?: A versão do elemento é atualizada no repositório, e ele fica disponível para outros editarem.
✅ Ver o Histórico
• O que é?: Mostra todas as alterações feitas em um elemento, incluindo quem alterou, quando e o que foi feito.
• Como fazer:
1 Clique com o botão direito no elemento.
2 Escolha SCM > View history.
3 Você verá uma lista com versões, datas, autores e comentários.
• Dica: Você pode comparar versões antigas para ver o que mudou (ex.: código WLanguage adicionado).
Exemplo prático: Se você está editando uma janela de cadastro, faz o check-out, adiciona um campo de e-mail, faz o check-in com o comentário “Adicionado campo e-mail”, e depois pode ver no histórico que você fez essa alteração hoje.
🛠️ Etapa 5: Usando Labels e Branches
🎯 Labels (Etiquetas)
• O que é?: Um “marco” que marca o estado do projeto em um momento específico, como o fim de uma sprint.
• Como criar:
1 Vá em SCM > Labels > Add a Label.
2 Dê um nome (ex.: “Versão 1.0 - Sprint 1”).
3 O SCM registra o estado atual de todos os elementos.
• Por que usar?: Permite voltar a uma versão estável ou gerar builds para clientes.
🌱 Branches (Ramificações)
• O que é?: Uma cópia do projeto para trabalhar em algo separado, como uma nova funcionalidade ou correção de bug.
• Como criar:
1 Vá em SCM > Branch management > Create a branch.
2 Dê um nome (ex.: “Func_CadastroCliente”).
3 Escolha a origem (geralmente a branch “main”).
• Como usar:
◦ Alternar entre branches: Vá em SCM > Branch management > Switch branch.
◦ Juntar alterações (merge): Quando terminar, use SCM > Branch management > Merge branch para combinar as mudanças com a branch principal.
• Exemplo: Você cria uma branch para adicionar um módulo de pagamento PIX. Enquanto isso, outro desenvolvedor corrige um bug na branch principal. Depois, vocês juntam tudo.
Dica: Assista ao vídeo da playlist sobre “Branches no SCM” para ver como criar e gerenciar branches visualmente.
🛠️ Etapa 6: Lidando com Conflitos
Conflitos acontecem quando duas pessoas tentam editar o mesmo elemento ou quando algo dá errado. Aqui estão as situações mais comuns e como resolvê-las:
Problema
Solução
Dois desenvolvedores editam o mesmo elemento
O SCM mostra um comparador visual para você decidir quais alterações manter.
Alguém esquece de fazer check-in
Um administrador pode forçar o desbloqueio em SCM > Manage check-outs.
Perdeu conexão com o HFSQL
Verifique o IP, porta e se o HFSQL Server está rodando.
Excluiu um elemento por engano
Use SCM > Restore deleted elements para recuperar.
Projeto corrompido
Use SCM > Recover project from SCM para baixar uma cópia nova.
Dica: Sempre faça check-in antes de sair do trabalho para evitar travar elementos.
🛠️ Etapa 7: Configurando Segurança e Permissões
O SCM permite controlar quem pode fazer o quê no projeto.
• Usuários normais podem:
◦ Fazer check-out e check-in.
◦ Ver histórico.
◦ Criar branches e labels.
• Administradores podem:
◦ Forçar desbloqueios.
◦ Gerenciar merges.
◦ Restaurar elementos excluídos.
◦ Auditar o histórico completo.
Como configurar:
1 No HFSQL Control Center, adicione usuários à base SCM.
2 Defina permissões (ex.: quem pode criar branches ou forçar desbloqueios).
3 Use SCM > Manage users na IDE para ajustar permissões.
🛠️ Etapa 8: Fazendo Backup da Base SCM
Para evitar perda de dados, faça backups regulares do repositório SCM.
1 Abra o HFSQL Control Center.
2 Configure backups automáticos:
◦ Escolha a base SCM (ex.: “SCM_MeuProjeto”).
◦ Agende backups diários ou semanais.
◦ Salve em um arquivo .DUMP ou .SQL.
3 Opcional: Configure replicação para outro servidor para maior segurança.
Dica: Faça um backup antes de grandes mudanças, como merges de branches.
🛠️ Etapa 9: Boas Práticas para Iniciantes
Aqui estão dicas para usar o SCM de forma eficiente:
1 Escreva comentários claros no check-in: Ex.: “Corrigi bug no cálculo de impostos” em vez de “Alteração”.
2 Crie labels ao final de cada sprint: Isso facilita voltar a versões estáveis.
3 Use branches para features ou clientes: Ex.: “Func_PagamentoPix” ou “Cliente_XYZ”.
4 Faça backups regulares: Use o HFSQL Control Center para automatizar.
5 Nunca deixe elementos travados: Sempre faça check-in antes de férias ou pausas.
6 Exporte labels para clientes: Use SCM > Export a label para criar um ZIP com uma versão específica.
🛠️ Etapa 10: Exemplo Prático
Imagine que você está desenvolvendo um sistema de vendas com uma equipe de três pessoas:
• Você: Trabalha na funcionalidade de “Cadastro de Clientes” em uma branch chamada “Func_Cadastro”.
• Colega 1: Corrige um bug no relatório de vendas na branch “Fix_Relatorio”.
• Líder: Faz o merge das duas branches na branch principal (“main”) para criar uma nova versão.
Passo a passo:
1 Você cria a branch Func_Cadastro e faz check-out da janela de cadastro.
2 Após editar, faz check-in com o comentário “Adicionado campo CPF”.
3 Colega 1 faz o mesmo na branch Fix_Relatorio.
4 O líder usa SCM > Merge branch para combinar tudo na “main” e cria uma label “Versão 1.1”.
Resultado: O projeto está atualizado, com histórico claro e uma versão estável pronta para testes.
📺 Usando a Playlist do YouTube
A playlist fornecida (link) tem vídeos úteis para visualizar os passos. Procure por:
• Vídeos sobre HFSQL: Para entender como configurar o servidor e criar a base SCM.
• Vídeos sobre SCM: Para ver como fazer check-out, check-in e criar branches.
• Vídeos de boas práticas: Para aprender a organizar branches e labels.
Se precisar de ajuda com um vídeo específico, me avise o título, e eu explico com base nele!
✅ Conclusão
O SCM do WinDev com HFSQL é uma ferramenta poderosa e fácil de usar para gerenciar projetos em equipe. Com este guia, você pode:
• Criar e configurar um repositório SCM.
• Adicionar projetos e gerenciar elementos.
• Fazer check-out, check-in e acompanhar o histórico.
• Usar labels e branches para organizar o trabalho.
• Resolver conflitos e manter backups.
Comece com um projeto pequeno para praticar, e logo você estará gerenciando projetos complexos com confiança!
Analisando seu manual completo do SCM do WinDev com HFSQL, posso identificar alguns pontos importantes que poderiam ser adicionados para torná-lo ainda mais abrangente para iniciantes:
## **Aspectos Técnicos que Faltaram:**
### **1. Configuração de Rede e Conectividade**
- Como configurar firewall para permitir conexões HFSQL (porta 4900)
- Configuração de IP fixo vs DHCP para servidores SCM
- Testagem de conectividade antes de criar o repositório
### **2. Estrutura de Pastas e Organização**
- Como organizar fisicamente os projetos no servidor
- Estrutura recomendada de diretórios para múltiplos projetos
- Localização dos arquivos de configuração do SCM
### **3. Migração e Importação**
- Como migrar um projeto existente (sem SCM) para o SCM
- Importação de projetos de outros sistemas de controle de versão
- Conversão de projetos locais para formato SCM
### **4. Administração Avançada**
- Configuração de logs detalhados
- Monitoramento de performance do repositório
- Limpeza de versões antigas (purge)
- Configuração de quotas de disco
### **5. Integração com Deploy**
- Como integrar o SCM com processo de build automático
- Configuração de ambientes (desenvolvimento, teste, produção)
- Geração automática de executáveis a partir de labels
## **Operações Práticas que Poderiam ser Expandidas:**
### **6. Cenários de Emergência**
- Recuperação quando o servidor HFSQL falha
- Restauração completa do repositório
- Procedimentos de contingência
### **7. Trabalho Offline**
- Como trabalhar quando não há conexão com o servidor
- Sincronização posterior de alterações offline
- Configuração de repositórios locais temporários
### **8. Integração com Ferramentas Externas**
- Conexão com sistemas de bug tracking
- Integração com ferramentas de CI/CD
- Exportação de relatórios para outras ferramentas
## **Aspectos de Equipe e Processo:**
### **9. Workflow e Metodologias**
- Implementação de Git Flow adaptado para SCM
- Políticas de merge e code review
- Definição de papéis e responsabilidades
### **10. Troubleshooting Comum**
- Problemas de performance com repositórios grandes
- Conflitos complexos de merge
- Erros de conectividade mais específicos
### **11. Versionamento de Banco de Dados**
- Como versionar estruturas de dados junto com o código
- Sincronização de análises HFSQL entre desenvolvedores
- Migrações de banco controladas pelo SCM
# Manual Completo Expandido do SCM do WinDev com HFSQL para Iniciantes
## 🌐 Aspectos Técnicos Avançados
### **1. Configuração de Rede e Conectividade**
#### **1.1 Configuração de Firewall**
Para que o SCM funcione corretamente em rede, é essencial configurar o firewall adequadamente:
**Windows Firewall:**
1. Abra o **Painel de Controle** → **Sistema e Segurança** → **Firewall do Windows**
1. Clique em **Configurações Avançadas**
1. Crie uma nova regra de entrada:
- Tipo: **Porta**
- Protocolo: **TCP**
- Porta específica: **4900** (porta padrão do HFSQL)
- Ação: **Permitir conexão**
- Perfil: Selecione todos (Domínio, Privada, Pública)
- Nome: “HFSQL Server - SCM”
**Firewall corporativo:**
- Solicite ao administrador de rede para liberar a porta 4900
- Se usar porta customizada, informe qual porta está sendo utilizada
- Teste conectividade com `telnet [IP_SERVIDOR] 4900`
#### **1.2 Configuração de IP Fixo vs DHCP**
**Para Servidores SCM (Recomendado: IP Fixo):**
```
Configuração recomendada:
- IP: 192.168.1.10 (exemplo)
- Máscara: 255.255.255.0
- Gateway: 192.168.1.1
- DNS: 8.8.8.8, 8.8.4.4
```
**Configuração no Windows:**
1. **Painel de Controle** → **Rede e Internet** → **Central de Rede**
1. Clique na conexão ativa → **Propriedades**
1. Selecione **Protocolo TCP/IPv4** → **Propriedades**
1. Marque **Usar o seguinte endereço IP**
1. Insira os dados acima
**Por que IP fixo?**
- Evita mudanças de endereço que quebrariam conexões SCM
- Facilita configuração de DNS interno
- Melhora performance ao evitar consultas DHCP
#### **1.3 Testagem de Conectividade**
**Teste básico de rede:**
```cmd
ping [IP_SERVIDOR]
telnet [IP_SERVIDOR] 4900
```
**Teste via HFSQL Control Center:**
1. Abra o **HFSQL Control Center**
1. Clique em **Conectar a um servidor HFSQL**
1. Insira IP, porta, usuário e senha
1. Se conectar com sucesso, a rede está OK
**Teste via WinDev:**
1. No WinDev, crie uma conexão temporária
1. Use **Arquitetura** → **Testar a conexão**
1. Verifique se aparece “Conexão bem-sucedida”
### **2. Estrutura de Pastas e Organização**
#### **2.1 Organização Física no Servidor**
**Estrutura recomendada:**
```
C:\HFSQL_Server\
├── Bases_SCM\
│ ├── Projeto_Principal\
│ │ ├── SCM_Principal.fic
│ │ ├── SCM_Principal.mmo
│ │ └── SCM_Principal.ndx
│ ├── Projeto_Cliente_A\
│ └── Projeto_Mobile_App\
├── Backups\
│ ├── Diarios\
│ ├── Semanais\
│ └── Mensais\
├── Logs\
│ ├── HFSQL_Server.log
│ └── Conexoes.log
└── Configuracao\
├── HFConf.ini
└── Usuarios.ini
```
**Configuração no HFSQL Control Center:**
1. **Configuração** → **Servidor** → **Caminhos**
1. Defina pasta padrão para bases: `C:\HFSQL_Server\Bases_SCM\`
1. Defina pasta para backups: `C:\HFSQL_Server\Backups\`
1. Defina pasta para logs: `C:\HFSQL_Server\Logs\`
#### **2.2 Localização dos Arquivos de Configuração**
**Arquivos importantes:**
- **HFConf.ini**: Configurações do servidor HFSQL
- Localização: `C:\ProgramData\PC SOFT\28.0\HFConf.ini`
- **Logs do servidor**: `C:\ProgramData\PC SOFT\28.0\Logs\`
- **Configurações SCM por projeto**: Armazenadas nas tabelas do próprio repositório
**Backup das configurações:**
```batch
@echo off
set DATA_BACKUP=%date:~6,4%-%date:~3,2%-%date:~0,2%
xcopy "C:\ProgramData\PC SOFT\28.0\*" "C:\HFSQL_Server\Backups\Config_%DATA_BACKUP%\" /E /Y
```
### **3. Migração e Importação**
#### **3.1 Migração de Projeto Existente (sem SCM) para SCM**
**Preparação:**
1. **Faça backup completo** do projeto original
1. **Compile o projeto** para verificar se não há erros
1. **Documente** as configurações atuais
**Processo de migração:**
1. **Crie o repositório SCM** (conforme Etapa 1 do manual original)
1. **No WinDev**, abra o projeto existente
1. Vá em **SCM** → **Add the project to the SCM**
1. **Selecione o repositório** criado
1. **Configure as opções**:
- ☑️ Adicionar todos os elementos
- ☑️ Fazer primeiro check-in automaticamente
- ☑️ Criar label “Versão Inicial”
**Verificação pós-migração:**
```
✓ Todos os elementos estão listados no SCM
✓ Projeto compila sem erros
✓ Histórico mostra a versão inicial
✓ Outros desenvolvedores conseguem abrir o projeto
```
#### **3.2 Importação de Outros Sistemas de Controle de Versão**
**Cenário comum: Migração do Git**
1. **Exporte** a versão mais recente do Git
1. **Remova** todos os arquivos `.git`
1. **Importe** para WinDev como projeto novo
1. **Adicione ao SCM** conforme processo acima
**Preservação do histórico:**
- O SCM não importa histórico de outros sistemas
- **Recomendação**: Mantenha o repositório antigo como referência
- **Documente** as versões importantes no novo SCM
#### **3.3 Conversão de Projetos Locais**
**Para projetos que nunca usaram controle de versão:**
1. **Organize** os arquivos em uma pasta limpa
1. **Remova** arquivos temporários (.tmp, .bak, etc.)
1. **Teste** a compilação
1. **Adicione ao SCM** seguindo o processo padrão
**Checklist de limpeza:**
```
□ Remover arquivos .tmp
□ Remover backups antigos (.bak)
□ Verificar se todos os recursos estão presentes
□ Testar em máquina limpa
□ Documentar dependências externas
```
## 🔧 Administração Avançada
### **4. Configuração Avançada do Servidor**
#### **4.1 Configuração de Logs Detalhados**
**Habilitando logs completos:**
1. **HFSQL Control Center** → **Configuração** → **Logs**
1. **Ative as seguintes opções**:
- ☑️ Log de conexões
- ☑️ Log de comandos SQL
- ☑️ Log de erros
- ☑️ Log de operações SCM
- ☑️ Log de performance
**Configuração no arquivo HFConf.ini:**
```ini
[LOGS]
Active=1
Path=C:\HFSQL_Server\Logs\
DetailLevel=3
MaxSize=100MB
RotateDaily=1
KeepDays=30
```
**Monitoramento de logs:**
```batch
# Script para monitorar logs em tempo real (PowerShell)
Get-Content "C:\HFSQL_Server\Logs\HFSQL_Server.log" -Wait -Tail 50
```
#### **4.2 Monitoramento de Performance**
**Métricas importantes a acompanhar:**
- **Conexões simultâneas**: Máximo recomendado 50 para SCM
- **Tempo de resposta**: Operações SCM devem ser < 2s
- **Uso de memória**: HFSQL Server não deve usar > 70% da RAM
- **Espaço em disco**: Manter pelo menos 20% livre
**Configuração de alertas:**
1. **Control Center** → **Monitoramento** → **Alertas**
1. **Configure alertas para**:
- Conexões > 40
- Tempo resposta > 5s
- Disco < 15% livre
- Servidor inacessível
**Script de monitoramento automático:**
```powershell
# Verificar status do HFSQL Server
$process = Get-Process "HFServer" -ErrorAction SilentlyContinue
if ($process) {
Write-Host "HFSQL Server: ONLINE"
Write-Host "Memória usada: $($process.WorkingSet64/1MB) MB"
} else {
Write-Host "HFSQL Server: OFFLINE" -ForegroundColor Red
# Enviar email de alerta
}
```
#### **4.3 Limpeza de Versões Antigas (Purge)**
**Quando fazer limpeza:**
- Repositório muito grande (> 10GB)
- Muitas versões antigas (> 100 versões por elemento)
- Performance degradada
**Processo de purge:**
1. **Planeje** fora do horário comercial
1. **Faça backup completo** antes
1. **No WinDev**: **SCM** → **Manage the SCM database** → **Purge**
1. **Configure critérios**:
- Manter versões dos últimos 6 meses
- OU manter apenas as 50 versões mais recentes
- Preservar sempre as versões com labels
**Configuração automática:**
```ini
[PURGE]
AutoPurge=1
KeepMonths=6
KeepMinVersions=10
KeepLabeledVersions=1
ScheduleTime=02:00
```
#### **4.4 Configuração de Quotas de Disco**
**Definindo limites por projeto:**
1. **Control Center** → **Bases** → **[Projeto]** → **Propriedades**
1. **Quota máxima**: 2GB por projeto (recomendado)
1. **Alerta em**: 80% da quota
1. **Bloqueio em**: 95% da quota
**Monitoramento de uso:**
```sql
-- Query para verificar tamanho dos repositórios
SELECT
DatabaseName,
SizeInMB = SUM(FileSizeInBytes) / 1048576
FROM HFSystemInfo
GROUP BY DatabaseName
ORDER BY SizeInMB DESC
```
## 🚀 Integração com Deploy e CI/CD
### **5. Integração Avançada com Deploy**
#### **5.1 Build Automático a partir de Labels**
**Script de build automático (PowerShell):**
```powershell
# Build-SCM-Project.ps1
param(
[string]$ProjectPath,
[string]$LabelName,
[string]$OutputPath
)
# Conectar ao SCM
$windev = New-Object -ComObject "WDApp.Application"
# Restaurar projeto pela label
$project = $windev.RestoreProjectFromSCM($ProjectPath, $LabelName)
# Compilar projeto
$result = $project.Compile()
if ($result.Success) {
Write-Host "Compilação bem-sucedida para label: $LabelName"
# Gerar executável
$exe = $project.GenerateExecutable($OutputPath)
Write-Host "Executável gerado em: $OutputPath"
} else {
Write-Error "Erro na compilação: $($result.ErrorMessage)"
exit 1
}
```
**Agendamento no Windows Task Scheduler:**
1. **Painel de Controle** → **Ferramentas Administrativas** → **Agendador de Tarefas**
1. **Criar Tarefa Básica**:
- Nome: “Build Automático SCM”
- Disparador: “Quando evento específico for registrado”
- Log: “Application”
- Fonte: “SCM-Build-Trigger”
- Ação: Executar o script PowerShell
#### **5.2 Configuração de Ambientes**
**Estrutura de ambientes:**
```
Desenvolvimento (DEV)
├── Branch: develop
├── Servidor: 192.168.1.10
├── Base: SCM_DEV
└── Auto-deploy: A cada commit
Teste (TST)
├── Branch: release/v1.x
├── Servidor: 192.168.1.20
├── Base: SCM_TST
└── Deploy: Manual via label
Produção (PRD)
├── Branch: main
├── Servidor: 192.168.1.30
├── Base: SCM_PRD
└── Deploy: Apenas labels aprovadas
```
**Script de deploy por ambiente:**
```batch
@echo off
set AMBIENTE=%1
set LABEL=%2
if "%AMBIENTE%"=="DEV" (
set SERVIDOR=192.168.1.10
set PASTA=\\servidor-dev\aplicacoes\
) else if "%AMBIENTE%"=="TST" (
set SERVIDOR=192.168.1.20
set PASTA=\\servidor-tst\aplicacoes\
) else if "%AMBIENTE%"=="PRD" (
set SERVIDOR=192.168.1.30
set PASTA=\\servidor-prd\aplicacoes\
) else (
echo Ambiente inválido: DEV, TST ou PRD
exit /b 1
)
echo Fazendo deploy da label %LABEL% para %AMBIENTE%...
call Build-SCM-Project.ps1 -LabelName "%LABEL%" -OutputPath "%PASTA%"
```
#### **5.3 Geração Automática de Executáveis**
**Configuração no projeto WinDev:**
1. **Projeto** → **Configuração do projeto** → **Executável**
1. **Ative**: “Geração automática após compilação bem-sucedida”
1. **Configure**:
- Pasta de saída: `\\servidor\deploys\[PROJETO]\[VERSAO]\`
- Nome do arquivo: `[PROJETO]_v[VERSAO]_[DATA].exe`
- Incluir dependências automaticamente
**Script para versionamento automático:**
```wlanguage
// Código WLanguage para versionar automaticamente
sMajor is string = "1"
sMinor is string = "0"
sBuild is string = IntToString(DateToInteger(DateSys()) - DateToInteger("20240101"))
sRevision is string = IntToString(TimeSysToInteger() / 100)
sVersion is string = StringBuild("%1.%2.%3.%4", sMajor, sMinor, sBuild, sRevision)
// Definir a versão no projeto
Project..VersionNumber = sVersion
```
## 🆘 Cenários de Emergência e Recuperação
### **6. Procedimentos de Emergência**
#### **6.1 Recuperação quando o Servidor HFSQL Falha**
**Diagnóstico rápido:**
```batch
# Verificar se o serviço está rodando
sc query "HFServer"
# Tentar reiniciar o serviço
net stop "HFServer"
net start "HFServer"
# Verificar logs de erro
type "C:\ProgramData\PC SOFT\28.0\Logs\HFServer.log" | findstr /i "error"
```
**Procedimento de recuperação:**
1. **Pare o serviço HFSQL**
1. **Verifique a integridade dos arquivos**:
```batch
# Usar ferramenta HFSQL para verificar
HFIndex.exe /CHECK /REPAIR "C:\HFSQL_Server\Bases_SCM\*.fic"
```
1. **Se corrupção detectada**:
- Restaure o backup mais recente
- Aplique logs de transação se disponíveis
1. **Reinicie o serviço**
1. **Teste conectividade** com todos os clientes
**Plano de contingência:**
```
TEMPO | AÇÃO
--------|----------------------------------------------------------
0-15min | Diagnóstico inicial, tentativa de reinício simples
15-30min| Verificação de integridade, reparo automático
30-60min| Restauração do backup, aplicação de logs
>60min | Ativação do servidor secundário (se disponível)
```
#### **6.2 Restauração Completa do Repositório**
**Processo de restauração completa:**
1. **Pare todos os clientes WinDev** conectados ao SCM
1. **Pare o serviço HFSQL Server**
1. **Remova** os arquivos corrompidos:
```batch
del "C:\HFSQL_Server\Bases_SCM\SCM_Projeto\*.*"
```
1. **Restaure** do backup mais recente:
```batch
copy "C:\HFSQL_Server\Backups\SCM_Projeto_20250710.dump"
"C:\HFSQL_Server\Restore\"
```
1. **Use o Control Center** para restaurar:
- **Arquivo** → **Restaurar base** → Selecione o arquivo .dump
1. **Reinicie o servidor** e **teste** a conectividade
**Validação pós-restauração:**
```
✓ Todos os projetos aparecem no SCM
✓ Histórico de versões está íntegro
✓ Labels e branches estão preservadas
✓ Usuários conseguem fazer check-out/check-in
✓ Não há elementos corrompidos
```
#### **6.3 Procedimentos de Contingência**
**Servidor secundário de backup:**
1. **Configure** um segundo servidor HFSQL
1. **Ative replicação automática**:
- **Control Center** → **Replicação** → **Novo**
- Tipo: **Replicação de servidor**
- Frequência: **A cada 15 minutos**
1. **Em caso de falha** do servidor principal:
- Redirecione clientes para o servidor secundário
- Atualize conexões SCM nos clientes
**Trabalho offline de emergência:**
1. **Exportar** última versão estável para cada desenvolvedor
1. **Coordenar** por email/chat quem trabalha em quê
1. **Quando servidor voltar**: Fazer merge manual das alterações
## 📱 Trabalho Offline e Sincronização
### **7. Configuração para Trabalho Offline**
#### **7.1 Preparação para Trabalho Offline**
**Antes de ficar offline:**
1. **Faça check-out** de todos os elementos que você vai editar
1. **Exporte** uma cópia local do projeto:
- **SCM** → **Export project from SCM**
- Pasta destino: `C:\Projetos_Offline\[PROJETO]`
1. **Documente** as alterações que pretende fazer
**Estrutura offline recomendada:**
```
C:\Projetos_Offline\
├── MeuProjeto_Offline\
│ ├── [Arquivos do projeto]
│ ├── CHANGELOG_Offline.txt
│ └── Elementos_EmEdicao.txt
└── Scripts_Sincronizacao\
├── Preparar_Offline.ps1
├── Sincronizar_Online.ps1
└── Validar_Conflitos.ps1
```
#### **7.2 Trabalhando Offline**
**Boas práticas offline:**
1. **Mantenha um log** detalhado das alterações:
```
Data/Hora | Elemento | Alteração
-------------|-------------------|---------------------------
10/07 09:30 | FRM_Cadastro.wdw | Adicionado campo telefone
10/07 10:15 | CLS_Cliente.wdc | Novo método ValidarCPF()
10/07 14:20 | QRY_Relatorio.sql| Otimizada consulta vendas
```
1. **Faça backups** locais frequentes:
```batch
# Script de backup local
set DATA=%date:~6,4%%date:~3,2%%date:~0,2%
xcopy "C:\Projetos_Offline\MeuProjeto\"
"C:\Projetos_Offline\Backups\%DATA%\" /E /Y
```
1. **Teste** regularmente a compilação offline
#### **7.3 Sincronização Posterior**
**Processo de sincronização:**
1. **Reconecte** ao servidor SCM
1. **Verifique** se outros fizeram alterações nos mesmos elementos
1. **Para cada elemento modificado**:
- Compare versão local vs servidor
- Resolva conflitos manualmente
- Faça merge das alterações
1. **Faça check-in** com comentários detalhados
**Script de sincronização semi-automática:**
```powershell
# Sincronizar-Projeto.ps1
param([string]$ProjetoLocal, [string]$ConexaoSCM)
$elementosModificados = Get-ChildItem $ProjetoLocal -Recurse |
Where-Object {$_.LastWriteTime -gt (Get-Date).AddDays(-1)}
foreach ($elemento in $elementosModificados) {
Write-Host "Verificando: $($elemento.Name)"
# Verificar se elemento foi modificado no servidor
$versaoServidor = Get-SCMElementVersion $elemento.Name $ConexaoSCM
$versaoLocal = Get-SCMElementVersion $elemento.Name "LOCAL"
if ($versaoServidor -gt $versaoLocal) {
Write-Warning "Conflito detectado em: $($elemento.Name)"
# Abrir ferramenta de merge
Start-Process "WDMerge.exe" -ArgumentList "$elemento.FullName"
}
}
```
#### **7.4 Repositórios Locais Temporários**
**Criando repositório local para equipe pequena:**
1. **Instale HFSQL** em laptop/servidor local
1. **Crie base SCM** temporária
1. **Importe** projeto do servidor principal
1. **Configure** clientes para usar servidor local
**Sincronização com servidor principal:**
```batch
# Quando conexão for restaurada
SCMSync.exe /SOURCE:"Local_SCM" /TARGET:"Servidor_Principal" /MERGE
```
## 🔌 Integração com Ferramentas Externas
### **8. Conexões com Sistemas Externos**
#### **8.1 Integração com Bug Tracking**
**Integração com Jira (exemplo):**
```wlanguage
// Função para criar link entre commit SCM e issue Jira
PROCEDURE LinkSCMToJira(sCommentSCM is string, sJiraIssue is string)
// Extrair número do issue do comentário
sIssueNumber is string = ExtractString(sCommentSCM, "[", "]")
IF sIssueNumber <> "" THEN
// Fazer chamada à API do Jira
sJiraURL is string = "https://empresa.atlassian.net/rest/api/3/issue/" + sIssueNumber
HTTPRequest HTTPHeader("Authorization: Basic " + Encode("usuario:token", encodeBASE64))
sJSONData is string = StringBuild('{
"update": {
"comment": [{
"add": {
"body": "Alteração realizada no SCM: %1"
}
}]
}
}', sCommentSCM)
sResponse is string = HTTPSend(sJiraURL, sJSONData, httpPUT)
END
```
**Configuração no SCM:**
1. **Hooks** pós-commit para chamar API externa
1. **Validação** de formato de comentários
1. **Log** de integrações para auditoria
#### **8.2 Integração com CI/CD (Jenkins, GitLab)**
**Webhook para Jenkins:**
```json
{
"trigger_url": "http://jenkins.empresa.com/job/Build-WinDev/buildWithParameters",
"parameters": {
"PROJECT_NAME": "{{project_name}}",
"SCM_LABEL": "{{label_name}}",
"BRANCH": "{{branch_name}}"
},
"authentication": {
"type": "token",
"token": "{{jenkins_token}}"
}
}
```
**Pipeline Jenkins para WinDev:**
```groovy
pipeline {
agent any
parameters {
string(name: 'PROJECT_NAME', defaultValue: 'MeuProjeto')
string(name: 'SCM_LABEL', defaultValue: 'latest')
string(name: 'BRANCH', defaultValue: 'main')
}
stages {
stage('Checkout from SCM') {
steps {
script {
// Exportar projeto do SCM
powershell """
./Export-SCM-Project.ps1
-Project "${params.PROJECT_NAME}"
-Label "${params.SCM_LABEL}"
-Output "./workspace"
"""
}
}
}
stage('Build') {
steps {
// Compilar projeto WinDev
bat "WDConver.exe /compile ./workspace/${params.PROJECT_NAME}.wdp"
}
}
stage('Test') {
steps {
// Executar testes automatizados
bat "WDTestRunner.exe ./workspace/Tests/"
}
}
stage('Deploy') {
when {
expression { params.SCM_LABEL != 'latest' }
}
steps {
// Deploy automático
bat "Deploy-Application.bat ${params.PROJECT_NAME} ${params.SCM_LABEL}"
}
}
}
post {
always {
// Limpar workspace
cleanWs()
}
success {
// Notificar sucesso
emailext to: 'dev-team@empresa.com',
subject: "Build successful: ${params.PROJECT_NAME}",
body: "Label ${params.SCM_LABEL} foi construída com sucesso."
}
failure {
// Notificar falha
emailext to: 'dev-team@empresa.com',
subject: "Build failed: ${params.PROJECT_NAME}",
body: "Falha ao construir label ${params.SCM_LABEL}."
}
}
}
```
#### **8.3 Exportação de Relatórios**
**Relatório de atividade SCM em Excel:**
```wlanguage
// Gerar relatório de commits para Excel
PROCEDURE GenerateActivityReport(dStartDate is Date, dEndDate is Date)
// Conectar ao repositório SCM
HOpenConnection(SCM_Connection)
// Query para buscar atividades
sQuery is string = [
SELECT
u.UserName,
e.ElementName,
v.VersionDate,
v.Comment,
v.VersionNumber
FROM SCM_VERSION v
INNER JOIN SCM_ELEMENT e ON v.ElementID = e.ElementID
INNER JOIN SCM_USER u ON v.UserID = u.UserID
WHERE v.VersionDate BETWEEN {d '%1'} AND {d '%2'}
ORDER BY v.VersionDate DESC
]
HExecuteSQLQuery(QRY_Report, StringBuild(sQuery, dStartDate, dEndDate))
// Exportar para Excel
HToFile(QRY_Report, "C:\Reports\SCM_Activity_" +
DateToString(DateSys(), "YYYYMMDD") + ".xlsx", hFileXLS)
Info("Relatório gerado: C:\Reports\SCM_Activity_" +
DateToString(DateSys(), "YYYYMMDD") + ".xlsx")
```
**Dashboard em tempo real (PowerBI/Grafana):**
```sql
-- View SQL para dashboard de métricas SCM
CREATE VIEW vw_SCM_Metrics AS
SELECT
-- Commits por dia
DATE(VersionDate) as CommitDate,
COUNT(*) as TotalCommits,
COUNT(DISTINCT UserID) as ActiveUsers,
COUNT(DISTINCT ElementID) as ModifiedElements,
-- Commits por usuário
UserName,
COUNT(*) as UserCommits,
-- Elementos mais modificados
ElementName,
COUNT(*) as ElementModifications
FROM SCM_VERSION v
INNER JOIN SCM_ELEMENT e ON v.ElementID = e.ElementID
INNER JOIN SCM_USER u ON v.UserID = u.UserID
WHERE VersionDate >= DATE_SUB(NOW(), INTERVAL 30 DAY)
GROUP BY DATE(VersionDate), UserName, ElementName
```
## 👥 Aspectos de Equipe e Workflow
### **9. Workflow e Metodologias**
#### **9.1 Implementação de Git Flow Adaptado para SCM**
**Estrutura de branches recomendada:**
```
main
├── develop
│ ├── feature/nova-funcionalidade
│ ├── feature/cadastro-clientes
│ └── feature/relatorio-vendas
├── release/v1.1.0
│ ├── bugfix/correcao-calculo
│ └── bugfix/interface-login
└── hotfix/emergencia-producao
```
**Política de branches:**
1. **main**: Sempre estável, apenas releases
1. **develop**: Integração contínua de features
1. **feature/***: Uma branch por funcionalidade
1. **release/***: Preparação de versões
1. **hotfix/***: Correções urgentes em produção
**Processo de desenvolvimento:**
```
1. Criar feature branch: SCM > Branch > Create from develop
2. Desenvolver funcionalidade
3. Merge para develop: SCM > Branch > Merge to develop
4. Teste em develop
5. Criar release branch: SCM > Branch > Create release/v1.x
6. Finalizar e merge para main
7. Criar label: SCM > Labels > Add Label "v1.x"
```
#### **9.2 Políticas de Merge e Code Review**
**Configuração de aprovação obrigatória:**
```ini
# Configuração no arquivo SCM.ini
[MERGE_POLICIES]
RequireApproval=1
MinApprovers=2
AllowSelfApproval=0
RequireComments=1
BlockDirectPush=main,release/*
```
**Processo de code review:**
1. **Desenvolvedor** faz check-in na feature branch
1. **Sistema** gera notificação para revisores
1. **Revisor** analisa alterações:
- **SCM** → **Compare versions** → Verificar diferenças
- Comentar diretamente no elemento
- Aprovar ou solicitar alterações
1. **Após aprovação**: Merge liberado para branch destino
**Template de comentários de review:**
```
REVISÃO DE CÓDIGO - [ELEMENTO]
==============================
✓ Funcionalidade: OK/PENDENTE
✓ Performance: OK/PENDENTE
✓ Segurança: OK/PENDENTE
✓ Padrões: OK/PENDENTE
COMENTÁRIOS:
- [Comentário específico]
- [Sugestão de melhoria]
APROVADO: SIM/NÃO
REVISOR: [Nome]
DATA: [Data]
```
#### **9.3 Definição de Papéis e Responsabilidades**
**Hierarquia de usuários SCM:**
Papel |Permissões |Responsabilidades |
--------------|----------------------------|-------------------------------------|
**SCM Admin** |Todas |Gerenciar servidor, usuários, backups|
**Tech Lead** |Merge, Labels, Branches |Aprovar merges, criar releases |
**Senior Dev**|Check-in/out, Branch, Review|Desenvolvimento, code review |
**Developer** |Check-in/out básico |Desenvolvimento de features |
**QA Tester** |Somente leitura, Labels |Testes, validação de releases |
**Matriz de responsabilidades (RACI):**
```
Atividade | Admin | Lead | Senior | Dev | QA
------------------------|-------|------|--------|-----|----
Criar repositório | R | C | I | I | I
Gerenciar branches | A | R | C | I | I
Code review | I | A | R | C | I
Criar releases | A | R | C | I | C
Fazer deploy | A | R | I | I | C
Backup do SCM | R | I | I | I | I
R=Responsible, A=Accountable, C=Consulted, I=Informed
```
## 🔍 Troubleshooting Avançado
### **10. Problemas Complexos e Soluções**
#### **10.1 Performance com Repositórios Grandes**
**Sintomas de performance ruim:**
- Check-out/check-in demoram > 30 segundos
- Interface SCM trava frequentemente
- Consulta ao histórico é muito lenta
- Servidor HFSQL usa > 80% CPU constantemente
**Diagnóstico:**
```sql
-- Verificar tamanho das tabelas SCM
SELECT
TableName,
RecordCount,
FileSizeKB = FileSize / 1024
FROM HFStat
WHERE TableName LIKE 'SCM_%'
ORDER BY FileSizeKB DESC
```
**Soluções:**
1. **Purge automático** das versões antigas:
```ini
[AUTO_PURGE]
Enabled=1
KeepVersions=50
KeepDays=180
ScheduleTime=02:00
```
1. **Indexação otimizada**:
```sql
-- Recriar índices importantes
DROP INDEX SCM_VERSION_DATE_IDX
CREATE INDEX SCM_VERSION_DATE_IDX ON SCM_VERSION(VersionDate, ElementID)
DROP INDEX SCM_ELEMENT_NAME_IDX
CREATE INDEX SCM_ELEMENT_NAME_IDX ON SCM_ELEMENT(ElementName, ProjectID)
```
1. **Configuração de cache**:
```ini
[CACHE]
CacheSize=512MB
IndexCache=128MB
QueryCache=256MB
ConnectionPool=20
```
#### **10.2 Conflitos Complexos de Merge**
**Cenário: Merge de branches com muitas alterações**
**Identificação de conflitos:**
```wlanguage
// Verificar conflitos antes do merge
PROCEDURE CheckMergeConflicts(sBranchSource, sBranchTarget)
sConflicts is string = ""
HExecuteSQLQuery(QRY_Conflicts, [
SELECT DISTINCT
e.ElementName,
COUNT(*) as ConflictCount
FROM SCM_VERSION v1
INNER JOIN SCM_VERSION v2 ON v1.ElementID = v2.ElementID
INNER JOIN SCM_ELEMENT e ON v1.ElementID = e.ElementID
WHERE v1.BranchID = %1
AND v2.BranchID = %2
AND v1.VersionDate > (SELECT LastMergeDate FROM SCM_BRANCH...)
GROUP BY e.ElementName
HAVING COUNT(*) > 1
], GetBranchID(sBranchSource), GetBranchID(sBranchTarget))
FOR EACH QRY_Conflicts
sConflicts += QRY_Conflicts.ElementName + " (" +
QRY_Conflicts.ConflictCount + " versões)" + CR
END
RETURN sConflicts
```
**Resolução manual de conflitos:**
1. **Identifique** elementos em conflito
1. **Para cada elemento**:
- Abra o comparador visual do SCM
- Analise as diferenças linha por linha
- Escolha quais alterações manter
- Crie nova versão mesclada
1. **Teste** a compilação após cada resolução
**Ferramentas auxiliares:**
```batch
# Script para backup antes de merge complexo
backup-before-merge.bat [BRANCH_NAME]
@echo off
set BRANCH=%1
set TIMESTAMP=%date:~6,4%%date:~3,2%%date:~0,2%_%time:~0,2%%time:~3,2%
echo Fazendo backup da branch %BRANCH% antes do merge...
SCMExport.exe /branch:"%BRANCH%" /output:"C:\Backups\PreMerge_%BRANCH%_%TIMESTAMP%"
echo Backup concluído: C:\Backups\PreMerge_%BRANCH%_%TIMESTAMP%
```
#### **10.3 Problemas de Conectividade Específicos**
**Erro: “Conexão perdida durante operação SCM”**
**Diagnóstico:**
```batch
# Teste de estabilidade da conexão
for /L %%i in (1,1,100) do (
echo Teste %%i:
ping -n 1 [IP_SERVIDOR] > nul
if errorlevel 1 (
echo %%i: FALHA >> conexao_log.txt
) else (
echo %%i: OK >> conexao_log.txt
)
timeout /t 5 > nul
)
```
**Soluções:**
1. **Timeout aumentado**:
```ini
[CONNECTION]
Timeout=300
RetryAttempts=3
RetryDelay=10
KeepAlive=1
```
1. **Conexão redundante**:
```ini
[FAILOVER]
PrimaryServer=192.168.1.10:4900
SecondaryServer=192.168.1.11:4900
AutoFailover=1
```
1. **Compressão de dados**:
```ini
[PERFORMANCE]
EnableCompression=1
CompressionLevel=6
```
## 🗄️ Versionamento de Banco de Dados
### **11. Controle de Versão de Estruturas de Dados**
#### **11.1 Versionamento de Análises HFSQL**
**Processo para versionar estrutura do banco:**
1. **Incluir arquivo de análise** (.WDD) no SCM
1. **Criar scripts de migração** para cada mudança
1. **Versionar** scripts junto com o código
**Estrutura recomendada:**
```
Projeto\
├── Análise\
│ ├── Projeto.wdd
│ └── Migrations\
│ ├── v1.0_inicial.sql
│ ├── v1.1_adicionar_campo_email.sql
│ └── v1.2_nova_tabela_produtos.sql
├── Sources\
└── Tests\
```
**Script de migração exemplo:**
```sql
-- v1.1_adicionar_campo_email.sql
-- Migração: Adicionar campo email na tabela CLIENTE
-- Verificar se a coluna já existe
IF NOT EXISTS (
SELECT * FROM INFORMATION_SCHEMA.COLUMNS
WHERE TABLE_NAME = 'CLIENTE' AND COLUMN_NAME = 'EMAIL'
) BEGIN
-- Adicionar coluna
ALTER TABLE CLIENTE ADD EMAIL VARCHAR(100)
-- Criar índice
CREATE INDEX IDX_CLIENTE_EMAIL ON CLIENTE(EMAIL)
-- Log da migração
INSERT INTO SCM_MIGRATIONS (Version, Description, AppliedDate)
VALUES ('1.1', 'Adicionar campo email na tabela CLIENTE', GETDATE())
END
```
#### **11.2 Sincronização de Análises entre Desenvolvedores**
**Problema comum:** Desenvolvedores com estruturas de banco diferentes
**Solução - Sistema de sincronização automática:**
```wlanguage
// Verificar se análise local está atualizada
PROCEDURE CheckAnalysisVersion()
// Conectar ao repositório SCM
HOpenConnection(SCM_Connection)
// Buscar versão da análise no servidor
sServerVersion is string = HExecuteSQLQuery([
SELECT TOP 1 AnalysisVersion
FROM SCM_PROJECT_INFO
WHERE ProjectID = %1
], gnCurrentProjectID)
// Comparar com versão local
sLocalVersion is string = HVersion()
IF sServerVersion <> sLocalVersion THEN
IF YesNo("Análise desatualizada. Atualizar automaticamente?") THEN
UpdateLocalAnalysis(sServerVersion)
END
END
```
**Script de atualização automática:**
```wlanguage
PROCEDURE UpdateLocalAnalysis(sTargetVersion)
// Baixar análise atualizada do SCM
HExecute([
SCM_GET_ANALYSIS %1 %2
], gnProjectID, sTargetVersion)
// Aplicar migrações pendentes
ExecutePendingMigrations(sTargetVersion)
// Recriar índices se necessário
RecreateIndexes()
// Atualizar versão local
HModify("PROJECT_INFO", [AnalysisVersion = sTargetVersion])
Info("Análise atualizada para versão: " + sTargetVersion)
```
#### **11.3 Migrações de Banco Controladas**
**Sistema de controle de migrações:**
```sql
-- Tabela para controlar migrações aplicadas
CREATE TABLE SCM_MIGRATIONS (
MigrationID INT IDENTITY(1,1) PRIMARY KEY,
Version VARCHAR(20) NOT NULL,
Description TEXT,
AppliedDate DATETIME DEFAULT GETDATE(),
AppliedBy VARCHAR(100),
ScriptPath VARCHAR(500),
Checksum VARCHAR(32)
)
```
**Aplicador automático de migrações:**
```wlanguage
PROCEDURE ApplyPendingMigrations()
// Buscar migrações disponíveis
garrMigrations is array of stMigration
LoadMigrationsFromSCM(garrMigrations)
// Buscar migrações já aplicadas
garrApplied is array of string
HExecuteSQLQuery(QRY_Applied, "SELECT Version FROM SCM_MIGRATIONS ORDER BY MigrationID")
FOR EACH QRY_Applied
Add(garrApplied, QRY_Applied.Version)
END
// Aplicar migrações pendentes
FOR EACH stMigration OF garrMigrations
IF SeekValue(garrApplied, stMigration.Version) = 0 THEN
Info("Aplicando migração: " + stMigration.Version)
// Executar script
sScript is string = LoadFileToString(stMigration.ScriptPath)
HExecuteSQLQuery(QRY_Migration, sScript)
// Registrar aplicação
HAdd(SCM_MIGRATIONS, [
Version = stMigration.Version,
Description = stMigration.Description,
AppliedBy = CurrentUser(),
ScriptPath = stMigration.ScriptPath,
Checksum = Crypt(sScript, "", cryptMD5)
])
Info("Migração " + stMigration.Version + " aplicada com sucesso")
END
END
```
**Rollback de migrações:**
```wlanguage
PROCEDURE RollbackMigration(sVersion)
// Verificar se migração foi aplicada
IF HSeek(SCM_MIGRATIONS, Version, sVersion) THEN
// Executar script de rollback
sRollbackScript is string = LoadFileToString(
StringReplace(SCM_MIGRATIONS.ScriptPath, ".sql", "_rollback.sql")
)
IF sRollbackScript <> "" THEN
HExecuteSQLQuery(QRY_Rollback, sRollbackScript)
// Remover registro da migração
HDelete(SCM_MIGRATIONS)
Info("Rollback da migração " + sVersion + " executado com sucesso")
ELSE
Error("Script de rollback não encontrado para versão " + sVersion)
END
ELSE
Error("Migração " + sVersion + " não foi aplicada")
END
```
## 📊 Monitoramento e Relatórios Avançados
### **12. Sistema de Monitoramento Completo**
**Dashboard em tempo real para administradores:**
```html
<!-- Dashboard-SCM.html -->
<!DOCTYPE html>
<html>
<head>
<title>SCM Monitor</title>
<script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
<style>
.metric-card {
background: #f5f5f5;
border-radius: 8px;
padding: 20px;
margin: 10px;
text-align: center;
box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}
.metric-value {
font-size: 2em;
font-weight: bold;
color: #2196F3;
}
</style>
</head>
<body>
<h1>SCM Monitoring Dashboard</h1>
<div class="metrics-container">
<div class="metric-card">
<div class="metric-value" id="activeUsers">-</div>
<div>Usuários Ativos</div>
</div>
<div class="metric-card">
<div class="metric-value" id="dailyCommits">-</div>
<div>Commits Hoje</div>
</div>
<div class="metric-card">
<div class="metric-value" id="repoSize">-</div>
<div>Tamanho Repositório</div>
</div>
</div>
<div id="commitsChart"></div>
<div id="usersChart"></div>
<script>
// Atualizar métricas a cada 30 segundos
setInterval(updateMetrics, 30000);
updateMetrics();
function updateMetrics() {
fetch('/api/scm-metrics')
.then(response => response.json())
.then(data => {
document.getElementById('activeUsers').textContent = data.activeUsers;
document.getElementById('dailyCommits').textContent = data.dailyCommits;
document.getElementById('repoSize').textContent = data.repoSizeMB + ' MB';
updateCharts(data);
});
}
function updateCharts(data) {
// Gráfico de commits por dia
Plotly.newPlot('commitsChart', [{
x: data.commitDates,
y: data.commitCounts,
type: 'scatter',
mode: 'lines+markers',
name: 'Commits por Dia'
}], {
title: 'Atividade de Commits - Últimos 30 Dias'
});
// Gráfico de atividade por usuário
Plotly.newPlot('usersChart', [{
x: data.userNames,
y: data.userCommits,
type: 'bar',
name: 'Commits por Usuário'
}], {
title: 'Atividade por Desenvolvedor - Esta Semana'
});
}
</script>
</body>
</html>
```
**API para fornecer métricas:**
```wlanguage
// Webservice para métricas do SCM
PROCEDURE WSGetSCMMetrics()
// Usuários ativos nas últimas 24h
nActiveUsers is int = HExecuteSQLQuery([
SELECT COUNT(DISTINCT UserID)
FROM SCM_VERSION
WHERE VersionDate >= DATEADD(day, -1, GETDATE())
])
// Commits hoje
nDailyCommits is int = HExecuteSQLQuery([
SELECT COUNT(*)
FROM SCM_VERSION
WHERE CAST(VersionDate AS DATE) = CAST(GETDATE() AS DATE)
])
// Tamanho do repositório
nRepoSize is int = HExecuteSQLQuery([
SELECT SUM(FileSizeBytes) / 1048576 as SizeMB
FROM SCM_FILE_DATA
])
// Commits por dia (últimos 30 dias)
sCommitHistory is string = HExecuteSQLQuery([
SELECT
CAST(VersionDate AS DATE) as CommitDate,
COUNT(*) as CommitCount
FROM SCM_VERSION
WHERE VersionDate >= DATEADD(day, -30, GETDATE())
GROUP BY CAST(VersionDate AS DATE)
ORDER BY CommitDate
])
// Retornar JSON
sJSON is string = [
{
"activeUsers": %1,
"dailyCommits": %2,
"repoSizeMB": %3,
"commitDates": %4,
"commitCounts": %5,
"userNames": %6,
"userCommits": %7
}
]
StringBuild(sJSON, nActiveUsers, nDailyCommits, nRepoSize, ...)
WebserviceWriteHTTPCode(200)
WebserviceWriteMimeType("application/json")
RESULT sJSON
```
-----
## 📋 Conclusão do Manual Expandido
Este manual expandido agora cobre todos os aspectos essenciais para uma implementação profissional do SCM com HFSQL, incluindo:
- **Configuração técnica avançada** com rede, firewall e monitoramento
- **Administração robusta** com backup, purge e quotas
- **Integração empresarial** com CI/CD, bug tracking e relatórios
- **Procedimentos de emergência** e recuperação de desastres
- **Workflow profissional** com Git Flow adaptado e code review
- **Versionamento de banco** com migrações controladas
- **Troubleshooting avançado** para problemas complexos
### **Próximos Passos Recomendados:**
1. **Implemente gradualmente** - Comece com as funcionalidades básicas
1. **Treine a equipe** - Use este manual como base para workshops
1. **Monitore constantemente** - Configure alertas e dashboards
1. **Documente personalizações** - Adapte o manual para sua realidade
1. **Mantenha backups** - Configure rotinas automáticas
1. **Atualize regularmente** - Acompanhe novas versões do WinDev/HFSQL
O SCM é uma ferramenta poderosa que, quando bem configurada, transforma a produtividade da equipe de desenvolvimento. Use este manual como referência e não hesite em experimentar as funcionalidades avançadas à medida que sua equipe ganha experiência.
**Dúvidas?** Este manual cobre a maioria dos cenários, mas cada ambiente é único.
Documente suas descobertas e compartilhe com a equipe para enriquecer ainda mais o conhecimento coletivo sobre o SCM!
--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 99949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/ |
| |
| |
| | | |
|
| | | | |
| | |
| | |
| |
|
|
|