//==============================================================================
// CLASSE: CRestCRUDServer
// Descrição: Classe para gerar automaticamente CRUD REST API de qualquer tabela
// Autor: Sistema Automático
// Data: 14/08/2025
//==============================================================================

CRestCRUDServer is Class
// Atributos privados
PRIVATE
m_sTableName is string
m_sConnectionString is string
m_stFieldsInfo is array of stFieldInfo
m_sPrimaryKey is string
m_stForeignKeys is array of stForeignKey
m_stMandatoryFields is array of string
m_nPort is int = 8080
m_sBasePath is string = “/api/v1”
END

// Estruturas auxiliares
stFieldInfo is Structure
sName is string
nType is int
nSize is int
bMandatory is boolean
bPrimaryKey is boolean
sDefaultValue is string
END

stForeignKey is Structure
sFieldName is string
sReferencedTable is string
sReferencedField is string
END

//==============================================================================
// MÉTODOS PÚBLICOS
//==============================================================================

//——————————————————————————
// Constructor: Inicializa a classe com a tabela/view/query
//——————————————————————————
PROCEDURE Constructor(sTableOrQuery is string, sConnection is string = “”)
m_sTableName = sTableOrQuery
m_sConnectionString = sConnection

```
// Analisa a estrutura da tabela/query
IF NOT AnalyzeTableStructure() THEN
ExceptionThrow(1, "Erro ao analisar estrutura da tabela: " + m_sTableName)
END
```

END

//——————————————————————————
// StartServer: Inicia o servidor REST
//——————————————————————————
PROCEDURE StartServer(nPort is int = 8080, sBasePath is string = “/api/v1”) : boolean
m_nPort = nPort
m_sBasePath = sBasePath

```
// Configura as rotas REST automaticamente
ConfigureRoutes()

// Inicia o servidor web
IF NOT WebServerStart(m_nPort) THEN
RESULT False
END

Info("Servidor REST iniciado na porta " + m_nPort + StringBuild(CR + "Endpoints disponíveis:" + CR + ...
"GET %1/%2 - Listar todos" + CR + ...
"GET %1/%2/{id} - Obter por ID" + CR + ...
"POST %1/%2 - Criar novo" + CR + ...
"PUT %1/%2/{id} - Atualizar" + CR + ...
"DELETE %1/%2/{id} - Excluir", m_sBasePath, m_sTableName))

RESULT True
```

END

//==============================================================================
// MÉTODOS PRIVADOS
//==============================================================================

//——————————————————————————
// AnalyzeTableStructure: Analisa dinamicamente a estrutura da tabela
//——————————————————————————
PRIVATE PROCEDURE AnalyzeTableStructure() : boolean
stField is stFieldInfo
sAnalysis is string
nFieldCount is int
i is int

```
TRY
// Obtém informações da análise
sAnalysis = HListFile()

// Verifica se a tabela existe na análise
IF Position(sAnalysis, m_sTableName, firstRank, IgnoreCase) = 0 THEN
// Tenta como query SQL
IF NOT AnalyzeSQLQuery() THEN
RESULT False
END
END

// Obtém número de campos
nFieldCount = HNbItem(m_sTableName)

// Analisa cada campo
FOR i = 1 TO nFieldCount
stField.sName = HListItem(m_sTableName, i)
stField.nType = HItemType(m_sTableName, stField.sName)
stField.nSize = HItemSize(m_sTableName, stField.sName)
stField.bMandatory = HItemIsMandatory(m_sTableName, stField.sName)
stField.bPrimaryKey = HItemIsKey(m_sTableName, stField.sName)

// Adiciona ao array de campos
ArrayAdd(m_stFieldsInfo, stField)

// Identifica chave primária
IF stField.bPrimaryKey THEN
m_sPrimaryKey = stField.sName
END

// Adiciona campos obrigatórios
IF stField.bMandatory THEN
ArrayAdd(m_stMandatoryFields, stField.sName)
END
END

// Analisa chaves estrangeiras
AnalyzeForeignKeys()

RESULT True

EXCEPTION
Error("Erro ao analisar estrutura: " + ExceptionInfo())
RESULT False
END
```

END

//——————————————————————————
// AnalyzeSQLQuery: Analisa query SQL personalizada
//——————————————————————————
PRIVATE PROCEDURE AnalyzeSQLQuery() : boolean
qryTemp is Data Source

```
TRY
// Executa a query para obter estrutura
IF HExecuteSQLQuery(qryTemp, m_sConnectionString, m_sTableName) THEN
// Usa HDescribeFile para obter estrutura da query
HDescribeFile(qryTemp)
m_sTableName = qryTemp..Name
RESULT True
END

RESULT False

EXCEPTION
RESULT False
END
```

END

//——————————————————————————
// AnalyzeForeignKeys: Identifica chaves estrangeiras
//——————————————————————————
PRIVATE PROCEDURE AnalyzeForeignKeys()
stFK is stForeignKey
i is int
sLinkInfo is string

```
FOR i = 1 TO ArrayCount(m_stFieldsInfo)
// Verifica se o campo é uma chave estrangeira
sLinkInfo = HListLink(m_sTableName, m_stFieldsInfo[i].sName)

IF sLinkInfo <> "" THEN
stFK.sFieldName = m_stFieldsInfo[i].sName
// Parse das informações de link (simplificado)
stFK.sReferencedTable = ExtractString(sLinkInfo, 1, TAB)
stFK.sReferencedField = ExtractString(sLinkInfo, 2, TAB)

ArrayAdd(m_stForeignKeys, stFK)
END
END
```

END

//——————————————————————————
// ConfigureRoutes: Configura as rotas REST automaticamente
//——————————————————————————
PRIVATE PROCEDURE ConfigureRoutes()
sTablePath is string = m_sBasePath + “/” + Lower(m_sTableName)

```
// GET /api/v1/table - Listar todos
WebAddRoute(sTablePath, httpGet, GetAllRecords)

// GET /api/v1/table/{id} - Obter por ID
WebAddRoute(sTablePath + "/{id}", httpGet, GetRecordByID)

// POST /api/v1/table - Criar novo
WebAddRoute(sTablePath, httpPost, CreateRecord)

// PUT /api/v1/table/{id} - Atualizar
WebAddRoute(sTablePath + "/{id}", httpPut, UpdateRecord)

// DELETE /api/v1/table/{id} - Excluir
WebAddRoute(sTablePath + "/{id}", httpDelete, DeleteRecord)

// OPTIONS para CORS
WebAddRoute(sTablePath, httpOptions, HandleCORS)
WebAddRoute(sTablePath + "/{id}", httpOptions, HandleCORS)
```

END

//——————————————————————————
// GetAllRecords: Retorna todos os registros (GET)
//——————————————————————————
PRIVATE PROCEDURE GetAllRecords()
sJSON is string
sFilter is string = “”
nLimit is int = 100
nOffset is int = 0

```
// Configurar CORS
SetCORSHeaders()

TRY
// Obtém parâmetros de consulta
sFilter = WebParameter("filter", parameterGet)
nLimit = Val(WebParameter("limit", parameterGet, "100"))
nOffset = Val(WebParameter("offset", parameterGet, "0"))

// Gera JSON com os registros
sJSON = GenerateRecordsJSON(sFilter, nLimit, nOffset)

// Retorna resposta
WebWriteHTTPCode(200)
WebWriteString(sJSON, "application/json")

EXCEPTION
HandleAPIError("Erro ao obter registros", 500)
END
```

END

//——————————————————————————
// GetRecordByID: Retorna registro específico por ID (GET)
//——————————————————————————
PRIVATE PROCEDURE GetRecordByID()
sID is string
sJSON is string

```
SetCORSHeaders()

TRY
sID = WebParameter("id", parameterURL)

IF sID = "" THEN
HandleAPIError("ID não informado", 400)
RETURN
END

// Busca o registro
sJSON = FindRecordByID(sID)

IF sJSON = "" THEN
HandleAPIError("Registro não encontrado", 404)
ELSE
WebWriteHTTPCode(200)
WebWriteString(sJSON, "application/json")
END

EXCEPTION
HandleAPIError("Erro ao buscar registro", 500)
END
```

END

//——————————————————————————
// CreateRecord: Cria novo registro (POST)
//——————————————————————————
PRIVATE PROCEDURE CreateRecord()
sJSONInput is string
sResponse is string
varRecord is Variant

```
SetCORSHeaders()

TRY
// Obtém JSON do body
sJSONInput = WebReadRequestBody()

IF sJSONInput = "" THEN
HandleAPIError("Dados não informados", 400)
RETURN
END

// Parse do JSON
JSONToVariant(varRecord, sJSONInput)

// Valida campos obrigatórios
IF NOT ValidateMandatoryFields(varRecord) THEN
RETURN // Erro já tratado na validação
END

// Cria o registro
sResponse = InsertRecord(varRecord)

WebWriteHTTPCode(201)
WebWriteString(sResponse, "application/json")

EXCEPTION
HandleAPIError("Erro ao criar registro: " + ExceptionInfo(), 500)
END
```

END

//——————————————————————————
// UpdateRecord: Atualiza registro existente (PUT)
//——————————————————————————
PRIVATE PROCEDURE UpdateRecord()
sID is string
sJSONInput is string
sResponse is string
varRecord is Variant

```
SetCORSHeaders()

TRY
sID = WebParameter("id", parameterURL)
sJSONInput = WebReadRequestBody()

IF sID = "" OR sJSONInput = "" THEN
HandleAPIError("ID ou dados não informados", 400)
RETURN
END

JSONToVariant(varRecord, sJSONInput)

// Atualiza o registro
sResponse = ModifyRecord(sID, varRecord)

IF sResponse = "" THEN
HandleAPIError("Registro não encontrado", 404)
ELSE
WebWriteHTTPCode(200)
WebWriteString(sResponse, "application/json")
END

EXCEPTION
HandleAPIError("Erro ao atualizar registro: " + ExceptionInfo(), 500)
END
```

END

//——————————————————————————
// DeleteRecord: Exclui registro (DELETE)
//——————————————————————————
PRIVATE PROCEDURE DeleteRecord()
sID is string

```
SetCORSHeaders()

TRY
sID = WebParameter("id", parameterURL)

IF sID = "" THEN
HandleAPIError("ID não informado", 400)
RETURN
END

IF RemoveRecord(sID) THEN
WebWriteHTTPCode(204) // No Content
ELSE
HandleAPIError("Registro não encontrado", 404)
END

EXCEPTION
HandleAPIError("Erro ao excluir registro: " + ExceptionInfo(), 500)
END
```

END

//==============================================================================
// MÉTODOS DE MANIPULAÇÃO DE DADOS
//==============================================================================

//——————————————————————————
// GenerateRecordsJSON: Gera JSON com registros da tabela
//——————————————————————————
PRIVATE PROCEDURE GenerateRecordsJSON(sFilter is string, nLimit is int, nOffset is int) : string
sJSON is string = “[”
bFirst is boolean = True
sFieldName is string
i is int
nCount is int = 0

```
// Usa indirection para acessar dinamicamente a tabela
{m_sTableName, indFile}..Filter = sFilter

HReadFirst({m_sTableName, indFile})

WHILE NOT HOut({m_sTableName, indFile}) AND nCount < nLimit
IF nCount >= nOffset THEN
IF NOT bFirst THEN
sJSON += ","
END

sJSON += "{"
bFirst = True

// Constrói JSON dinamicamente usando informações dos campos
FOR i = 1 TO ArrayCount(m_stFieldsInfo)
sFieldName = m_stFieldsInfo[i].sName

IF NOT bFirst THEN
sJSON += ","
END

sJSON += """" + sFieldName + """:"
sJSON += FormatFieldValue(sFieldName, {m_sTableName + "." + sFieldName, indFile})

bFirst = False
END

sJSON += "}"
bFirst = False
END

nCount++
HReadNext({m_sTableName, indFile})
END

sJSON += "]"
RESULT sJSON
```

END

//——————————————————————————
// FindRecordByID: Busca registro por ID
//——————————————————————————
PRIVATE PROCEDURE FindRecordByID(sID is string) : string
sJSON is string = “”
sFieldName is string
i is int

```
// Busca usando chave primária com indirection
IF HReadSeekFirst({m_sTableName, indFile}, {m_sPrimaryKey, indFile}, sID) THEN
sJSON = "{"

FOR i = 1 TO ArrayCount(m_stFieldsInfo)
sFieldName = m_stFieldsInfo[i].sName

IF i > 1 THEN
sJSON += ","
END

sJSON += """" + sFieldName + """:"
sJSON += FormatFieldValue(sFieldName, {m_sTableName + "." + sFieldName, indFile})
END

sJSON += "}"
END

RESULT sJSON
```

END

//——————————————————————————
// InsertRecord: Insere novo registro
//——————————————————————————
PRIVATE PROCEDURE InsertRecord(varRecord is Variant) : string
sFieldName is string
i is int

```
// Limpa registro atual
HReset({m_sTableName, indFile})

// Preenche campos usando indirection
FOR i = 1 TO ArrayCount(m_stFieldsInfo)
sFieldName = m_stFieldsInfo[i].sName

IF VariantExists(varRecord, sFieldName) THEN
{m_sTableName + "." + sFieldName, indFile} = varRecord[sFieldName]
END
END

// Insere o registro
IF HAdd({m_sTableName, indFile}) THEN
// Retorna o registro inserido
RESULT FindRecordByID({m_sTableName + "." + m_sPrimaryKey, indFile})
ELSE
ExceptionThrow(2, "Erro ao inserir registro: " + HErrorInfo())
END
```

END

//——————————————————————————
// ModifyRecord: Modifica registro existente
//——————————————————————————
PRIVATE PROCEDURE ModifyRecord(sID is string, varRecord is Variant) : string
sFieldName is string
i is int

```
// Busca o registro
IF NOT HReadSeekFirst({m_sTableName, indFile}, {m_sPrimaryKey, indFile}, sID) THEN
RESULT ""
END

// Atualiza campos
FOR i = 1 TO ArrayCount(m_stFieldsInfo)
sFieldName = m_stFieldsInfo[i].sName

// Não atualiza chave primária
IF sFieldName <> m_sPrimaryKey AND VariantExists(varRecord, sFieldName) THEN
{m_sTableName + "." + sFieldName, indFile} = varRecord[sFieldName]
END
END

// Salva modificações
IF HModify({m_sTableName, indFile}) THEN
RESULT FindRecordByID(sID)
ELSE
ExceptionThrow(3, "Erro ao modificar registro: " + HErrorInfo())
END
```

END

//——————————————————————————
// RemoveRecord: Remove registro
//——————————————————————————
PRIVATE PROCEDURE RemoveRecord(sID is string) : boolean
IF HReadSeekFirst({m_sTableName, indFile}, {m_sPrimaryKey, indFile}, sID) THEN
RESULT HDelete({m_sTableName, indFile})
END

```
RESULT False
```

END

//==============================================================================
// MÉTODOS AUXILIARES
//==============================================================================

//——————————————————————————
// FormatFieldValue: Formata valor do campo para JSON
//——————————————————————————
PRIVATE PROCEDURE FormatFieldValue(sFieldName is string, vValue is Variant) : string
nType is int

```
// Obtém o tipo do campo
nType = HItemType(m_sTableName, sFieldName)

SWITCH nType
CASE hItemText, hItemMemo, hItemBinaryMemo
RESULT """" + Replace(vValue, """", "\""") + """"

CASE hItemDate
IF vValue = "" OR vValue = "00000000" THEN
RESULT "null"
ELSE
RESULT """" + DateToString(vValue, "YYYY-MM-DD") + """"
END

CASE hItemTime
IF vValue = "" OR vValue = "0000" THEN
RESULT "null"
ELSE
RESULT """" + TimeToString(vValue, "HH:MM:SS") + """"
END

CASE hItemDateTime
IF vValue = "" THEN
RESULT "null"
ELSE
RESULT """" + DateTimeToString(vValue, "YYYY-MM-DD HH:MM:SS") + """"
END

CASE hItemBoolean
RESULT IIF(vValue, "true", "false")

CASE hItemNumeric, hItemReal, hItemCurrency
IF vValue = 0 OR vValue = "" THEN
RESULT "0"
ELSE
RESULT Replace(vValue, ",", ".")
END

DEFAULT
IF vValue = Null THEN
RESULT "null"
ELSE
RESULT """" + vValue + """"
END
END
```

END

//——————————————————————————
// ValidateMandatoryFields: Valida campos obrigatórios
//——————————————————————————
PRIVATE PROCEDURE ValidateMandatoryFields(varRecord is Variant) : boolean
i is int
sField is string
sMissingFields is string = “”

```
FOR i = 1 TO ArrayCount(m_stMandatoryFields)
sField = m_stMandatoryFields[i]

IF NOT VariantExists(varRecord, sField) OR varRecord[sField] = "" THEN
IF sMissingFields <> "" THEN
sMissingFields += ", "
END
sMissingFields += sField
END
END

IF sMissingFields <> "" THEN
HandleAPIError("Campos obrigatórios não informados: " + sMissingFields, 400)
RESULT False
END

RESULT True
```

END

//——————————————————————————
// SetCORSHeaders: Define headers CORS
//——————————————————————————
PRIVATE PROCEDURE SetCORSHeaders()
WebWriteHTTPHeader(“Access-Control-Allow-Origin”, “*”)
WebWriteHTTPHeader(“Access-Control-Allow-Methods”, “GET, POST, PUT, DELETE, OPTIONS”)
WebWriteHTTPHeader(“Access-Control-Allow-Headers”, “Content-Type, Authorization”)
END

//——————————————————————————
// HandleCORS: Trata requisições OPTIONS
//——————————————————————————
PRIVATE PROCEDURE HandleCORS()
SetCORSHeaders()
WebWriteHTTPCode(204)
END

//——————————————————————————
// HandleAPIError: Trata erros da API
//——————————————————————————
PRIVATE PROCEDURE HandleAPIError(sMessage is string, nCode is int = 500)
sErrorJSON is string

```
SetCORSHeaders()

sErrorJSON = StringBuild("{\""error\"": {\""message\"": \""%1\"", \""code\"": %2}}", sMessage, nCode)

WebWriteHTTPCode(nCode)
WebWriteString(sErrorJSON, "application/json")
```

END

//==============================================================================
// CLASSE: CRestCRUDClient
// Descrição: Classe cliente para consumir a API REST CRUD
// Autor: Sistema Automático
// Data: 14/08/2025
//==============================================================================

CRestCRUDClient is Class
// Atributos privados
PRIVATE
m_sBaseURL is string
m_sTableName is string
m_sAuthToken is string
m_nTimeout is int = 30000
END

//==============================================================================
// MÉTODOS PÚBLICOS
//==============================================================================

//——————————————————————————
// Constructor: Inicializa cliente da API
//——————————————————————————
PROCEDURE Constructor(sBaseURL is string, sTableName is string, sAuthToken is string = “”)
m_sBaseURL = sBaseURL
m_sTableName = sTableName
m_sAuthToken = sAuthToken

```
// Remove barra final da URL se existir
IF Right(m_sBaseURL, 1) = "/" THEN
m_sBaseURL = Left(m_sBaseURL, Length(m_sBaseURL) - 1)
END
```

END

//——————————————————————————
// GetAll: Obtém todos os registros
//——————————————————————————
PROCEDURE GetAll(sFilter is string = “”, nLimit is int = 100, nOffset is int = 0) : Variant
sURL is string
sResponse is string
varResult is Variant

```
// Constrói URL com parâmetros
sURL = m_sBaseURL + "/" + Lower(m_sTableName)

IF sFilter <> "" OR nLimit <> 100 OR nOffset <> 0 THEN
sURL += "?"

IF sFilter <> "" THEN
sURL += "filter=" + URLEncode(sFilter) + "&"
END

IF nLimit <> 100 THEN
sURL += "limit=" + nLimit + "&"
END

IF nOffset <> 0 THEN
sURL += "offset=" + nOffset + "&"
END

// Remove último &
sURL = Left(sURL, Length(sURL) - 1)
END

// Faz requisição GET
sResponse = ExecuteHTTPRequest("GET", sURL)

// Converte resposta para Variant
JSONToVariant(varResult, sResponse)

RESULT varResult
```

END

//——————————————————————————
// GetByID: Obtém registro por ID
//——————————————————————————
PROCEDURE GetByID(ID is string) : Variant
sURL is string
sResponse is string
varResult is Variant

```
sURL = m_sBaseURL + "/" + Lower(m_sTableName) + "/" + ID

sResponse = ExecuteHTTPRequest("GET", sURL)

JSONToVariant(varResult, sResponse)

RESULT varResult
```

END

//——————————————————————————
// Create: Cria novo registro
//——————————————————————————
PROCEDURE Create(varData is Variant) : Variant
sURL is string
sJSON is string
sResponse is string
varResult is Variant

```
sURL = m_sBaseURL + "/" + Lower(m_sTableName)

// Converte dados para JSON
sJSON = VariantToJSON(varData)

// Faz requisição POST
sResponse = ExecuteHTTPRequest("POST", sURL, sJSON)

JSONToVariant(varResult, sResponse)

RESULT varResult
```

END

//——————————————————————————
// Update: Atualiza registro existente
//——————————————————————————
PROCEDURE Update(ID is string, varData is Variant) : Variant
sURL is string
sJSON is string
sResponse is string
varResult is Variant

```
sURL = m_sBaseURL + "/" + Lower(m_sTableName) + "/" + ID

sJSON = VariantToJSON(varData)

sResponse = ExecuteHTTPRequest("PUT", sURL, sJSON)

JSONToVariant(varResult, sResponse)

RESULT varResult
```

END

//——————————————————————————
// Delete: Exclui registro
//——————————————————————————
PROCEDURE Delete(ID is string) : boolean
sURL is string
sResponse is string

```
sURL = m_sBaseURL + "/" + Lower(m_sTableName) + "/" + ID

TRY
sResponse = ExecuteHTTPRequest("DELETE", sURL)
RESULT True
EXCEPTION
RESULT False
END
```

END

//——————————————————————————
// SetTimeout: Define timeout das requisições
//——————————————————————————
PROCEDURE SetTimeout(nTimeoutMS is int)
m_nTimeout = nTimeoutMS
END

//==============================================================================
// MÉTODOS PRIVADOS
//==============================================================================

//——————————————————————————
// ExecuteHTTPRequest: Executa requisição HTTP
//——————————————————————————
PRIVATE PROCEDURE ExecuteHTTPRequest(sMethod is string, sURL is string, sData is string = “”) : string
cHTTPRequest is httpRequest
cHTTPResponse is httpResponse

```
// Configura requisição
cHTTPRequest.URL = sURL
cHTTPRequest.Method = sMethod
cHTTPRequest.Timeout = m_nTimeout

// Headers padrão
cHTTPRequest.Header["Content-Type"] = "application/json"
cHTTPRequest.Header["Accept"] = "application/json"

// Token de autenticação se informado
IF m_sAuthToken <> "" THEN
cHTTPRequest.Header["Authorization"] = "Bearer " + m_sAuthToken
END

// Dados para POST/PUT
IF sData <> "" THEN
cHTTPRequest.Content = sData
END

// Executa requisição
cHTTPResponse = HTTPSend(cHTTPRequest)

// Verifica resposta
IF cHTTPResponse.StatusCode >= 200 AND cHTTPResponse.StatusCode < 300 THEN
RESULT cHTTPResponse.Content
ELSE
ExceptionThrow(cHTTPResponse.StatusCode, "Erro HTTP " + cHTTPResponse.StatusCode + ": " + cHTTPResponse.Content)
END
```

END

//==============================================================================
// EXEMPLO DE USO DAS CLASSES
//==============================================================================

// Exemplo servidor:
/*
// Cria servidor CRUD para tabela Cliente
crudServer is CRestCRUDServer(“Cliente”)

// Inicia o servidor na porta 8080
crudServer.StartServer(8080, “/api/v1”)
*/

// Exemplo cliente:
/*
// Cria cliente da API
clienteAPI is CRestCRUDClient(“http://localhost:8080/api/v1”, “cliente”)

// Cria novo cliente
novoCliente is Variant
novoCliente.nome = “João Silva”
novoCliente.email = “joao@email.com”
novoCliente.telefone = “11999999999”

clienteCriado is Variant = clienteAPI.Create(novoCliente)
Info(“Cliente criado com ID: “ + clienteCriado.id)

// Busca todos os clientes
todosClientes is Variant = clienteAPI.GetAll()
Info(“Total de clientes: “ + ArrayCount(todosClientes))

// Busca cliente por ID
cliente is Variant = clienteAPI.GetByID(“1”)
Info(“Nome do cliente: “ + cliente.nome)

// Atualiza cliente
dadosAtualizacao is Variant
dadosAtualizacao.telefone = “11888888888”
clienteAtualizado is Variant = clienteAPI.Update(“1”, dadosAtualizacao)

// Exclui cliente
IF clienteAPI.Delete(“1”) THEN
Info(“Cliente excluído com sucesso”)
END
*/

//==============================================================================
// CLASSE: CRestCRUDServer
// Descrição: Classe para gerar automaticamente CRUD REST API de qualquer tabela
// Autor: Sistema Automático
// Data: 14/08/2025
//==============================================================================

CRestCRUDServer is Class
// Atributos privados
PRIVATE
m_sTableName is string
m_sConnectionString is string
m_stFieldsInfo is array of stFieldInfo
m_sPrimaryKey is string
m_stForeignKeys is array of stForeignKey
m_stMandatoryFields is array of string
m_nPort is int = 8080
m_sBasePath is string = “/api/v1”
END

// Estruturas auxiliares
stFieldInfo is Structure
sName is string
nType is int
nSize is int
bMandatory is boolean
bPrimaryKey is boolean
sDefaultValue is string
END

stForeignKey is Structure
sFieldName is string
sReferencedTable is string
sReferencedField is string
END

//==============================================================================
// MÉTODOS PÚBLICOS
//==============================================================================

//——————————————————————————
// Constructor: Inicializa a classe com a tabela/view/query
//——————————————————————————
PROCEDURE Constructor(sTableOrQuery is string, sConnection is string = “”)
m_sTableName = sTableOrQuery
m_sConnectionString = sConnection

```
// Analisa a estrutura da tabela/query
IF NOT AnalyzeTableStructure() THEN
ExceptionThrow(1, "Erro ao analisar estrutura da tabela: " + m_sTableName)
END
```

END

//——————————————————————————
// StartServer: Inicia o servidor REST
//——————————————————————————
PROCEDURE StartServer(nPort is int = 8080, sBasePath is string = “/api/v1”) : boolean
m_nPort = nPort
m_sBasePath = sBasePath

```
// Configura as rotas REST automaticamente
ConfigureRoutes()

// Inicia o servidor web
IF NOT WebServerStart(m_nPort) THEN
RESULT False
END

Info("Servidor REST iniciado na porta " + m_nPort + StringBuild(CR + "Endpoints disponíveis:" + CR + ...
"GET %1/%2 - Listar todos" + CR + ...
"GET %1/%2/{id} - Obter por ID" + CR + ...
"POST %1/%2 - Criar novo" + CR + ...
"PUT %1/%2/{id} - Atualizar" + CR + ...
"DELETE %1/%2/{id} - Excluir", m_sBasePath, m_sTableName))

RESULT True
```

END

//==============================================================================
// MÉTODOS PRIVADOS
//==============================================================================

//——————————————————————————
// AnalyzeTableStructure: Analisa dinamicamente a estrutura da tabela
//——————————————————————————
PRIVATE PROCEDURE AnalyzeTableStructure() : boolean
stField is stFieldInfo
sAnalysis is string
nFieldCount is int
i is int

```
TRY
// Obtém informações da análise
sAnalysis = HListFile()

// Verifica se a tabela existe na análise
IF Position(sAnalysis, m_sTableName, firstRank, IgnoreCase) = 0 THEN
// Tenta como query SQL
IF NOT AnalyzeSQLQuery() THEN
RESULT False
END
END

// Obtém número de campos
nFieldCount = HNbItem(m_sTableName)

// Analisa cada campo
FOR i = 1 TO nFieldCount
stField.sName = HListItem(m_sTableName, i)
stField.nType = HItemType(m_sTableName, stField.sName)
stField.nSize = HItemSize(m_sTableName, stField.sName)
stField.bMandatory = HItemIsMandatory(m_sTableName, stField.sName)
stField.bPrimaryKey = HItemIsKey(m_sTableName, stField.sName)

// Adiciona ao array de campos
ArrayAdd(m_stFieldsInfo, stField)

// Identifica chave primária
IF stField.bPrimaryKey THEN
m_sPrimaryKey = stField.sName
END

// Adiciona campos obrigatórios
IF stField.bMandatory THEN
ArrayAdd(m_stMandatoryFields, stField.sName)
END
END

// Analisa chaves estrangeiras
AnalyzeForeignKeys()

RESULT True

EXCEPTION
Error("Erro ao analisar estrutura: " + ExceptionInfo())
RESULT False
END
```

END

//——————————————————————————
// AnalyzeSQLQuery: Analisa query SQL personalizada
//——————————————————————————
PRIVATE PROCEDURE AnalyzeSQLQuery() : boolean
qryTemp is Data Source

```
TRY
// Executa a query para obter estrutura
IF HExecuteSQLQuery(qryTemp, m_sConnectionString, m_sTableName) THEN
// Usa HDescribeFile para obter estrutura da query
HDescribeFile(qryTemp)
m_sTableName = qryTemp..Name
RESULT True
END

RESULT False

EXCEPTION
RESULT False
END
```

END

//——————————————————————————
// AnalyzeForeignKeys: Identifica chaves estrangeiras
//——————————————————————————
PRIVATE PROCEDURE AnalyzeForeignKeys()
stFK is stForeignKey
i is int
sLinkInfo is string

```
FOR i = 1 TO ArrayCount(m_stFieldsInfo)
// Verifica se o campo é uma chave estrangeira
sLinkInfo = HListLink(m_sTableName, m_stFieldsInfo[i].sName)

IF sLinkInfo <> "" THEN
stFK.sFieldName = m_stFieldsInfo[i].sName
// Parse das informações de link (simplificado)
stFK.sReferencedTable = ExtractString(sLinkInfo, 1, TAB)
stFK.sReferencedField = ExtractString(sLinkInfo, 2, TAB)

ArrayAdd(m_stForeignKeys, stFK)
END
END
```

END

//——————————————————————————
// ConfigureRoutes: Configura as rotas REST automaticamente
//——————————————————————————
PRIVATE PROCEDURE ConfigureRoutes()
sTablePath is string = m_sBasePath + “/” + Lower(m_sTableName)

```
// GET /api/v1/table - Listar todos
WebAddRoute(sTablePath, httpGet, GetAllRecords)

// GET /api/v1/table/{id} - Obter por ID
WebAddRoute(sTablePath + "/{id}", httpGet, GetRecordByID)

// POST /api/v1/table - Criar novo
WebAddRoute(sTablePath, httpPost, CreateRecord)

// PUT /api/v1/table/{id} - Atualizar
WebAddRoute(sTablePath + "/{id}", httpPut, UpdateRecord)

// DELETE /api/v1/table/{id} - Excluir
WebAddRoute(sTablePath + "/{id}", httpDelete, DeleteRecord)

// OPTIONS para CORS
WebAddRoute(sTablePath, httpOptions, HandleCORS)
WebAddRoute(sTablePath + "/{id}", httpOptions, HandleCORS)
```

END

//——————————————————————————
// GetAllRecords: Retorna todos os registros (GET)
//——————————————————————————
PRIVATE PROCEDURE GetAllRecords()
sJSON is string
sFilter is string = “”
nLimit is int = 100
nOffset is int = 0

```
// Configurar CORS
SetCORSHeaders()

TRY
// Obtém parâmetros de consulta
sFilter = WebParameter("filter", parameterGet)
nLimit = Val(WebParameter("limit", parameterGet, "100"))
nOffset = Val(WebParameter("offset", parameterGet, "0"))

// Gera JSON com os registros
sJSON = GenerateRecordsJSON(sFilter, nLimit, nOffset)

// Retorna resposta
WebWriteHTTPCode(200)
WebWriteString(sJSON, "application/json")

EXCEPTION
HandleAPIError("Erro ao obter registros", 500)
END
```

END

//——————————————————————————
// GetRecordByID: Retorna registro específico por ID (GET)
//——————————————————————————
PRIVATE PROCEDURE GetRecordByID()
sID is string
sJSON is string

```
SetCORSHeaders()

TRY
sID = WebParameter("id", parameterURL)

IF sID = "" THEN
HandleAPIError("ID não informado", 400)
RETURN
END

// Busca o registro
sJSON = FindRecordByID(sID)

IF sJSON = "" THEN
HandleAPIError("Registro não encontrado", 404)
ELSE
WebWriteHTTPCode(200)
WebWriteString(sJSON, "application/json")
END

EXCEPTION
HandleAPIError("Erro ao buscar registro", 500)
END
```

END

//——————————————————————————
// CreateRecord: Cria novo registro (POST)
//——————————————————————————
PRIVATE PROCEDURE CreateRecord()
sJSONInput is string
sResponse is string
varRecord is Variant

```
SetCORSHeaders()

TRY
// Obtém JSON do body
sJSONInput = WebReadRequestBody()

IF sJSONInput = "" THEN
HandleAPIError("Dados não informados", 400)
RETURN
END

// Parse do JSON
JSONToVariant(varRecord, sJSONInput)

// Valida campos obrigatórios
IF NOT ValidateMandatoryFields(varRecord) THEN
RETURN // Erro já tratado na validação
END

// Cria o registro
sResponse = InsertRecord(varRecord)

WebWriteHTTPCode(201)
WebWriteString(sResponse, "application/json")

EXCEPTION
HandleAPIError("Erro ao criar registro: " + ExceptionInfo(), 500)
END
```

END

//——————————————————————————
// UpdateRecord: Atualiza registro existente (PUT)
//——————————————————————————
PRIVATE PROCEDURE UpdateRecord()
sID is string
sJSONInput is string
sResponse is string
varRecord is Variant

```
SetCORSHeaders()

TRY
sID = WebParameter("id", parameterURL)
sJSONInput = WebReadRequestBody()

IF sID = "" OR sJSONInput = "" THEN
HandleAPIError("ID ou dados não informados", 400)
RETURN
END

JSONToVariant(varRecord, sJSONInput)

// Atualiza o registro
sResponse = ModifyRecord(sID, varRecord)

IF sResponse = "" THEN
HandleAPIError("Registro não encontrado", 404)
ELSE
WebWriteHTTPCode(200)
WebWriteString(sResponse, "application/json")
END

EXCEPTION
HandleAPIError("Erro ao atualizar registro: " + ExceptionInfo(), 500)
END
```

END

//——————————————————————————
// DeleteRecord: Exclui registro (DELETE)
//——————————————————————————
PRIVATE PROCEDURE DeleteRecord()
sID is string

```
SetCORSHeaders()

TRY
sID = WebParameter("id", parameterURL)

IF sID = "" THEN
HandleAPIError("ID não informado", 400)
RETURN
END

IF RemoveRecord(sID) THEN
WebWriteHTTPCode(204) // No Content
ELSE
HandleAPIError("Registro não encontrado", 404)
END

EXCEPTION
HandleAPIError("Erro ao excluir registro: " + ExceptionInfo(), 500)
END
```

END

//==============================================================================
// MÉTODOS DE MANIPULAÇÃO DE DADOS
//==============================================================================

//——————————————————————————
// GenerateRecordsJSON: Gera JSON com registros da tabela
//——————————————————————————
PRIVATE PROCEDURE GenerateRecordsJSON(sFilter is string, nLimit is int, nOffset is int) : string
sJSON is string = “[”
bFirst is boolean = True
sFieldName is string
i is int
nCount is int = 0

```
// Usa indirection para acessar dinamicamente a tabela
{m_sTableName, indFile}..Filter = sFilter

HReadFirst({m_sTableName, indFile})

WHILE NOT HOut({m_sTableName, indFile}) AND nCount < nLimit
IF nCount >= nOffset THEN
IF NOT bFirst THEN
sJSON += ","
END

sJSON += "{"
bFirst = True

// Constrói JSON dinamicamente usando informações dos campos
FOR i = 1 TO ArrayCount(m_stFieldsInfo)
sFieldName = m_stFieldsInfo[i].sName

IF NOT bFirst THEN
sJSON += ","
END

sJSON += """" + sFieldName + """:"
sJSON += FormatFieldValue(sFieldName, {m_sTableName + "." + sFieldName, indFile})

bFirst = False
END

sJSON += "}"
bFirst = False
END

nCount++
HReadNext({m_sTableName, indFile})
END

sJSON += "]"
RESULT sJSON
```

END

//——————————————————————————
// FindRecordByID: Busca registro por ID
//——————————————————————————
PRIVATE PROCEDURE FindRecordByID(sID is string) : string
sJSON is string = “”
sFieldName is string
i is int

```
// Busca usando chave primária com indirection
IF HReadSeekFirst({m_sTableName, indFile}, {m_sPrimaryKey, indFile}, sID) THEN
sJSON = "{"

FOR i = 1 TO ArrayCount(m_stFieldsInfo)
sFieldName = m_stFieldsInfo[i].sName

IF i > 1 THEN
sJSON += ","
END

sJSON += """" + sFieldName + """:"
sJSON += FormatFieldValue(sFieldName, {m_sTableName + "." + sFieldName, indFile})
END

sJSON += "}"
END

RESULT sJSON
```

END

//——————————————————————————
// InsertRecord: Insere novo registro
//——————————————————————————
PRIVATE PROCEDURE InsertRecord(varRecord is Variant) : string
sFieldName is string
i is int

```
// Limpa registro atual
HReset({m_sTableName, indFile})

// Preenche campos usando indirection
FOR i = 1 TO ArrayCount(m_stFieldsInfo)
sFieldName = m_stFieldsInfo[i].sName

IF VariantExists(varRecord, sFieldName) THEN
{m_sTableName + "." + sFieldName, indFile} = varRecord[sFieldName]
END
END

// Insere o registro
IF HAdd({m_sTableName, indFile}) THEN
// Retorna o registro inserido
RESULT FindRecordByID({m_sTableName + "." + m_sPrimaryKey, indFile})
ELSE
ExceptionThrow(2, "Erro ao inserir registro: " + HErrorInfo())
END
```

END

//——————————————————————————
// ModifyRecord: Modifica registro existente
//——————————————————————————
PRIVATE PROCEDURE ModifyRecord(sID is string, varRecord is Variant) : string
sFieldName is string
i is int

```
// Busca o registro
IF NOT HReadSeekFirst({m_sTableName, indFile}, {m_sPrimaryKey, indFile}, sID) THEN
RESULT ""
END

// Atualiza campos
FOR i = 1 TO ArrayCount(m_stFieldsInfo)
sFieldName = m_stFieldsInfo[i].sName

// Não atualiza chave primária
IF sFieldName <> m_sPrimaryKey AND VariantExists(varRecord, sFieldName) THEN
{m_sTableName + "." + sFieldName, indFile} = varRecord[sFieldName]
END
END

// Salva modificações
IF HModify({m_sTableName, indFile}) THEN
RESULT FindRecordByID(sID)
ELSE
ExceptionThrow(3, "Erro ao modificar registro: " + HErrorInfo())
END
```

END

//——————————————————————————
// RemoveRecord: Remove registro
//——————————————————————————
PRIVATE PROCEDURE RemoveRecord(sID is string) : boolean
IF HReadSeekFirst({m_sTableName, indFile}, {m_sPrimaryKey, indFile}, sID) THEN
RESULT HDelete({m_sTableName, indFile})
END

```
RESULT False
```

END

//==============================================================================
// MÉTODOS AUXILIARES
//==============================================================================

//——————————————————————————
// FormatFieldValue: Formata valor do campo para JSON
//——————————————————————————
PRIVATE PROCEDURE FormatFieldValue(sFieldName is string, vValue is Variant) : string
nType is int

```
// Obtém o tipo do campo
nType = HItemType(m_sTableName, sFieldName)

SWITCH nType
CASE hItemText, hItemMemo, hItemBinaryMemo
RESULT """" + Replace(vValue, """", "\""") + """"

CASE hItemDate
IF vValue = "" OR vValue = "00000000" THEN
RESULT "null"
ELSE
RESULT """" + DateToString(vValue, "YYYY-MM-DD") + """"
END

CASE hItemTime
IF vValue = "" OR vValue = "0000" THEN
RESULT "null"
ELSE
RESULT """" + TimeToString(vValue, "HH:MM:SS") + """"
END

CASE hItemDateTime
IF vValue = "" THEN
RESULT "null"
ELSE
RESULT """" + DateTimeToString(vValue, "YYYY-MM-DD HH:MM:SS") + """"
END

CASE hItemBoolean
RESULT IIF(vValue, "true", "false")

CASE hItemNumeric, hItemReal, hItemCurrency
IF vValue = 0 OR vValue = "" THEN
RESULT "0"
ELSE
RESULT Replace(vValue, ",", ".")
END

DEFAULT
IF vValue = Null THEN
RESULT "null"
ELSE
RESULT """" + vValue + """"
END
END
```

END

//——————————————————————————
// ValidateMandatoryFields: Valida campos obrigatórios
//——————————————————————————
PRIVATE PROCEDURE ValidateMandatoryFields(varRecord is Variant) : boolean
i is int
sField is string
sMissingFields is string = “”

```
FOR i = 1 TO ArrayCount(m_stMandatoryFields)
sField = m_stMandatoryFields[i]

IF NOT VariantExists(varRecord, sField) OR varRecord[sField] = "" THEN
IF sMissingFields <> "" THEN
sMissingFields += ", "
END
sMissingFields += sField
END
END

IF sMissingFields <> "" THEN
HandleAPIError("Campos obrigatórios não informados: " + sMissingFields, 400)
RESULT False
END

RESULT True
```

END

//——————————————————————————
// SetCORSHeaders: Define headers CORS
//——————————————————————————
PRIVATE PROCEDURE SetCORSHeaders()
WebWriteHTTPHeader(“Access-Control-Allow-Origin”, “*”)
WebWriteHTTPHeader(“Access-Control-Allow-Methods”, “GET, POST, PUT, DELETE, OPTIONS”)
WebWriteHTTPHeader(“Access-Control-Allow-Headers”, “Content-Type, Authorization”)
END

//——————————————————————————
// HandleCORS: Trata requisições OPTIONS
//——————————————————————————
PRIVATE PROCEDURE HandleCORS()
SetCORSHeaders()
WebWriteHTTPCode(204)
END

//——————————————————————————
// HandleAPIError: Trata erros da API
//——————————————————————————
PRIVATE PROCEDURE HandleAPIError(sMessage is string, nCode is int = 500)
sErrorJSON is string

```
SetCORSHeaders()

sErrorJSON = StringBuild("{\""error\"": {\""message\"": \""%1\"", \""code\"": %2}}", sMessage, nCode)

WebWriteHTTPCode(nCode)
WebWriteString(sErrorJSON, "application/json")
```

END

//==============================================================================
// CLASSE: CRestCRUDClient
// Descrição: Classe cliente para consumir a API REST CRUD
// Autor: Sistema Automático
// Data: 14/08/2025
//==============================================================================

CRestCRUDClient is Class
// Atributos privados
PRIVATE
m_sBaseURL is string
m_sTableName is string
m_sAuthToken is string
m_nTimeout is int = 30000
END

//==============================================================================
// MÉTODOS PÚBLICOS
//==============================================================================

//——————————————————————————
// Constructor: Inicializa cliente da API
//——————————————————————————
PROCEDURE Constructor(sBaseURL is string, sTableName is string, sAuthToken is string = “”)
m_sBaseURL = sBaseURL
m_sTableName = sTableName
m_sAuthToken = sAuthToken

```
// Remove barra final da URL se existir
IF Right(m_sBaseURL, 1) = "/" THEN
m_sBaseURL = Left(m_sBaseURL, Length(m_sBaseURL) - 1)
END
```

END

//——————————————————————————
// GetAll: Obtém todos os registros
//——————————————————————————
PROCEDURE GetAll(sFilter is string = “”, nLimit is int = 100, nOffset is int = 0) : Variant
sURL is string
sResponse is string
varResult is Variant

```
// Constrói URL com parâmetros
sURL = m_sBaseURL + "/" + Lower(m_sTableName)

IF sFilter <> "" OR nLimit <> 100 OR nOffset <> 0 THEN
sURL += "?"

IF sFilter <> "" THEN
sURL += "filter=" + URLEncode(sFilter) + "&"
END

IF nLimit <> 100 THEN
sURL += "limit=" + nLimit + "&"
END

IF nOffset <> 0 THEN
sURL += "offset=" + nOffset + "&"
END

// Remove último &
sURL = Left(sURL, Length(sURL) - 1)
END

// Faz requisição GET
sResponse = ExecuteHTTPRequest("GET", sURL)

// Converte resposta para Variant
JSONToVariant(varResult, sResponse)

RESULT varResult
```

END

//——————————————————————————
// GetByID: Obtém registro por ID
//——————————————————————————
PROCEDURE GetByID(ID is string) : Variant
sURL is string
sResponse is string
varResult is Variant

```
sURL = m_sBaseURL + "/" + Lower(m_sTableName) + "/" + ID

sResponse = ExecuteHTTPRequest("GET", sURL)

JSONToVariant(varResult, sResponse)

RESULT varResult
```

END

//——————————————————————————
// Create: Cria novo registro
//——————————————————————————
PROCEDURE Create(varData is Variant) : Variant
sURL is string
sJSON is string
sResponse is string
varResult is Variant

```
sURL = m_sBaseURL + "/" + Lower(m_sTableName)

// Converte dados para JSON
sJSON = VariantToJSON(varData)

// Faz requisição POST
sResponse = ExecuteHTTPRequest("POST", sURL, sJSON)

JSONToVariant(varResult, sResponse)

RESULT varResult
```

END

//——————————————————————————
// Update: Atualiza registro existente
//——————————————————————————
PROCEDURE Update(ID is string, varData is Variant) : Variant
sURL is string
sJSON is string
sResponse is string
varResult is Variant

```
sURL = m_sBaseURL + "/" + Lower(m_sTableName) + "/" + ID

sJSON = VariantToJSON(varData)

sResponse = ExecuteHTTPRequest("PUT", sURL, sJSON)

JSONToVariant(varResult, sResponse)

RESULT varResult
```

END

//——————————————————————————
// Delete: Exclui registro
//——————————————————————————
PROCEDURE Delete(ID is string) : boolean
sURL is string
sResponse is string

```
sURL = m_sBaseURL + "/" + Lower(m_sTableName) + "/" + ID

TRY
sResponse = ExecuteHTTPRequest("DELETE", sURL)
RESULT True
EXCEPTION
RESULT False
END
```

END

//——————————————————————————
// SetTimeout: Define timeout das requisições
//——————————————————————————
PROCEDURE SetTimeout(nTimeoutMS is int)
m_nTimeout = nTimeoutMS
END

//==============================================================================
// MÉTODOS PRIVADOS
//==============================================================================

//——————————————————————————
// ExecuteHTTPRequest: Executa requisição HTTP
//——————————————————————————
PRIVATE PROCEDURE ExecuteHTTPRequest(sMethod is string, sURL is string, sData is string = “”) : string
cHTTPRequest is httpRequest
cHTTPResponse is httpResponse

```
// Configura requisição
cHTTPRequest.URL = sURL
cHTTPRequest.Method = sMethod
cHTTPRequest.Timeout = m_nTimeout

// Headers padrão
cHTTPRequest.Header["Content-Type"] = "application/json"
cHTTPRequest.Header["Accept"] = "application/json"

// Token de autenticação se informado
IF m_sAuthToken <> "" THEN
cHTTPRequest.Header["Authorization"] = "Bearer " + m_sAuthToken
END

// Dados para POST/PUT
IF sData <> "" THEN
cHTTPRequest.Content = sData
END

// Executa requisição
cHTTPResponse = HTTPSend(cHTTPRequest)

// Verifica resposta
IF cHTTPResponse.StatusCode >= 200 AND cHTTPResponse.StatusCode < 300 THEN
RESULT cHTTPResponse.Content
ELSE
ExceptionThrow(cHTTPResponse.StatusCode, "Erro HTTP " + cHTTPResponse.StatusCode + ": " + cHTTPResponse.Content)
END
```

END

//==============================================================================
// EXEMPLO DE USO DAS CLASSES
//==============================================================================

// Exemplo servidor:
/*
// Cria servidor CRUD para tabela Cliente
crudServer is CRestCRUDServer(“Cliente”)

// Inicia o servidor na porta 8080
crudServer.StartServer(8080, “/api/v1”)
*/

// Exemplo cliente:
/*
// Cria cliente da API
clienteAPI is CRestCRUDClient(“http://localhost:8080/api/v1”, “cliente”)

// Cria novo cliente
novoCliente is Variant
novoCliente.nome = “João Silva”
novoCliente.email = “joao@email.com”
novoCliente.telefone = “11999999999”

clienteCriado is Variant = clienteAPI.Create(novoCliente)
Info(“Cliente criado com ID: “ + clienteCriado.id)

// Busca todos os clientes
todosClientes is Variant = clienteAPI.GetAll()
Info(“Total de clientes: “ + ArrayCount(todosClientes))

// Busca cliente por ID
cliente is Variant = clienteAPI.GetByID(“1”)
Info(“Nome do cliente: “ + cliente.nome)

// Atualiza cliente
dadosAtualizacao is Variant
dadosAtualizacao.telefone = “11888888888”
clienteAtualizado is Variant = clienteAPI.Update(“1”, dadosAtualizacao)

// Exclui cliente
IF clienteAPI.Delete(“1”) THEN
Info(“Cliente excluído com sucesso”)
END
*/

//==============================================================================
// CLASSE: CRestCRUDManager
// Descrição: Gerenciador avançado para múltiplas tabelas e relacionamentos
// Autor: Sistema Automático
// Data: 14/08/2025
//==============================================================================

CRestCRUDManager is Class
PRIVATE
m_stServers is array of stServerInfo
m_stRelationships is array of stTableRelation
m_sConnectionString is string
m_nBasePort is int = 8080
END

// Estruturas para gerenciamento avançado
stServerInfo is Structure
sTableName is string
cServer is CRestCRUDServer
nPort is int
sBasePath is string
bActive is boolean
END

stTableRelation is Structure
sParentTable is string
sChildTable is string
sParentField is string
sChildField is string
sRelationType is string // “one-to-many”, “many-to-one”, “many-to-many”
END

//==============================================================================
// MÉTODOS DO GERENCIADOR AVANÇADO
//==============================================================================

//——————————————————————————
// Constructor: Inicializa gerenciador
//——————————————————————————
PROCEDURE Constructor(sConnection is string = “”, nBasePort is int = 8080)
m_sConnectionString = sConnection
m_nBasePort = nBasePort

```
// Auto-descobre todas as tabelas do projeto
AutoDiscoverTables()
```

END

//——————————————————————————
// AutoDiscoverTables: Descobre automaticamente todas as tabelas
//——————————————————————————
PROCEDURE AutoDiscoverTables()
sTables is string
sTable is string
nPos is int = 1
stServer is stServerInfo

```
// Lista todas as tabelas da análise
sTables = HListFile()

WHILE nPos <= Length(sTables)
sTable = ExtractString(sTables, nPos, CR)

IF sTable <> "" AND Left(sTable, 1) <> "." THEN
// Cria servidor para cada tabela
stServer.sTableName = sTable
stServer.cServer = new CRestCRUDServer(sTable, m_sConnectionString)
stServer.nPort = m_nBasePort + ArrayCount(m_stServers)
stServer.sBasePath = "/api/v1"
stServer.bActive = False

ArrayAdd(m_stServers, stServer)
END

nPos++
END

// Analisa relacionamentos
AnalyzeAllRelationships()
```

END

//——————————————————————————
// StartAllServers: Inicia servidores para todas as tabelas
//——————————————————————————
PROCEDURE StartAllServers() : boolean
i is int
bSuccess is boolean = True

```
FOR i = 1 TO ArrayCount(m_stServers)
IF m_stServers[i].cServer.StartServer(m_stServers[i].nPort, m_stServers[i].sBasePath) THEN
m_stServers[i].bActive = True
Trace("Servidor iniciado: " + m_stServers[i].sTableName + " na porta " + m_stServers[i].nPort)
ELSE
bSuccess = False
Error("Falha ao iniciar servidor para: " + m_stServers[i].sTableName)
END
END

RESULT bSuccess
```

END

//——————————————————————————
// StartServerForTable: Inicia servidor específico para uma tabela
//——————————————————————————
PROCEDURE StartServerForTable(sTableName is string) : boolean
i is int

```
FOR i = 1 TO ArrayCount(m_stServers)
IF Upper(m_stServers[i].sTableName) = Upper(sTableName) THEN
IF m_stServers[i].cServer.StartServer(m_stServers[i].nPort, m_stServers[i].sBasePath) THEN
m_stServers[i].bActive = True
RESULT True
END
END
END

RESULT False
```

END

//——————————————————————————
// GetAPIDocumentation: Gera documentação automática da API
//——————————————————————————
PROCEDURE GetAPIDocumentation() : string
sDoc is string
i is int
j is int

```
sDoc = "# API REST - Documentação Automática" + CR + CR
sDoc += "## Tabelas Disponíveis:" + CR + CR

FOR i = 1 TO ArrayCount(m_stServers)
sDoc += "### " + m_stServers[i].sTableName + CR
sDoc += "**Porta:** " + m_stServers[i].nPort + CR
sDoc += "**Status:** " + IIF(m_stServers[i].bActive, "Ativo", "Inativo") + CR
sDoc += "**Base URL:** http://localhost:" + m_stServers[i].nPort + m_stServers[i].sBasePath + CR + CR

sDoc += "**Endpoints:**" + CR
sDoc += "- GET /" + Lower(m_stServers[i].sTableName) + " - Listar todos" + CR
sDoc += "- GET /" + Lower(m_stServers[i].sTableName) + "/{id} - Obter por ID" + CR
sDoc += "- POST /" + Lower(m_stServers[i].sTableName) + " - Criar novo" + CR
sDoc += "- PUT /" + Lower(m_stServers[i].sTableName) + "/{id} - Atualizar" + CR
sDoc += "- DELETE /" + Lower(m_stServers[i].sTableName) + "/{id} - Excluir" + CR + CR
END

// Adiciona informações sobre relacionamentos
IF ArrayCount(m_stRelationships) > 0 THEN
sDoc += "## Relacionamentos Detectados:" + CR + CR

FOR j = 1 TO ArrayCount(m_stRelationships)
sDoc += "- " + m_stRelationships[j].sParentTable + "." + m_stRelationships[j].sParentField
sDoc += " → " + m_stRelationships[j].sChildTable + "." + m_stRelationships[j].sChildField
sDoc += " (" + m_stRelationships[j].sRelationType + ")" + CR
END
END

RESULT sDoc
```

END

//——————————————————————————
// AnalyzeAllRelationships: Analisa relacionamentos entre tabelas
//——————————————————————————
PRIVATE PROCEDURE AnalyzeAllRelationships()
i is int
j is int
sLinks is string
sLink is string
nLinkPos is int
stRelation is stTableRelation

```
FOR i = 1 TO ArrayCount(m_stServers)
sLinks = HListLink(m_stServers[i].sTableName)
nLinkPos = 1

WHILE nLinkPos <= Length(sLinks)
sLink = ExtractString(sLinks, nLinkPos, CR)

IF sLink <> "" THEN
// Parse do relacionamento
stRelation.sChildTable = m_stServers[i].sTableName
stRelation.sChildField = ExtractString(sLink, 1, TAB)
stRelation.sParentTable = ExtractString(sLink, 2, TAB)
stRelation.sParentField = ExtractString(sLink, 3, TAB)
stRelation.sRelationType = "many-to-one"

ArrayAdd(m_stRelationships, stRelation)
END

nLinkPos++
END
END
```

END

//==============================================================================
// CLASSE: CRestCRUDHelper
// Descrição: Utilitários e helpers para facilitar desenvolvimento
// Autor: Sistema Automático
// Data: 14/08/2025
//==============================================================================

CRestCRUDHelper is Class

END

//==============================================================================
// MÉTODOS ESTÁTICOS UTILITÁRIOS
//==============================================================================

//——————————————————————————
// GenerateClientCode: Gera código cliente automaticamente
//——————————————————————————
PROCEDURE STATIC GenerateClientCode(sTableName is string, sBaseURL is string) : string
sCode is string
sClassName is string

```
sClassName = "C" + sTableName + "API"

sCode = "// Classe cliente gerada automaticamente para " + sTableName + CR
sCode += sClassName + " is Class" + CR
sCode += " PRIVATE" + CR
sCode += " m_cClient is CRestCRUDClient" + CR
sCode += "END" + CR + CR

sCode += "PROCEDURE Constructor()" + CR
sCode += " m_cClient = new CRestCRUDClient(""" + sBaseURL + """, """ + Lower(sTableName) + """)" + CR
sCode += "END" + CR + CR

// Métodos específicos para a tabela
sCode += "PROCEDURE List" + sTableName + "(sFilter is string = """") : Variant" + CR
sCode += " RESULT m_cClient.GetAll(sFilter)" + CR
sCode += "END" + CR + CR

sCode += "PROCEDURE Get" + sTableName + "(ID is string) : Variant" + CR
sCode += " RESULT m_cClient.GetByID(ID)" + CR
sCode += "END" + CR + CR

sCode += "PROCEDURE Create" + sTableName + "(var" + sTableName + " is Variant) : Variant" + CR
sCode += " RESULT m_cClient.Create(var" + sTableName + ")" + CR
sCode += "END" + CR + CR

sCode += "PROCEDURE Update" + sTableName + "(ID is string, var" + sTableName + " is Variant) : Variant" + CR
sCode += " RESULT m_cClient.Update(ID, var" + sTableName + ")" + CR
sCode += "END" + CR + CR

sCode += "PROCEDURE Delete" + sTableName + "(ID is string) : boolean" + CR
sCode += " RESULT m_cClient.Delete(ID)" + CR
sCode += "END" + CR

RESULT sCode
```

END

//——————————————————————————
// GenerateSwaggerDoc: Gera documentação Swagger/OpenAPI
//——————————————————————————
PROCEDURE STATIC GenerateSwaggerDoc(sTableName is string, stFields is array of stFieldInfo) : string
sSwagger is string
i is int

```
sSwagger = "{" + CR
sSwagger += " ""openapi"": ""3.0.0""," + CR
sSwagger += " ""info"": {" + CR
sSwagger += " ""title"": """ + sTableName + " API""," + CR
sSwagger += " ""version"": ""1.0.0""," + CR
sSwagger += " ""description"": ""API REST para tabela " + sTableName + """" + CR
sSwagger += " }," + CR
sSwagger += " ""paths"": {" + CR

// GET All
sSwagger += " ""/" + Lower(sTableName) + """: {" + CR
sSwagger += " ""get"": {" + CR
sSwagger += " ""summary"": ""Listar todos os registros""," + CR
sSwagger += " ""parameters"": [" + CR
sSwagger += " {""name"": ""filter"", ""in"": ""query"", ""schema"": {""type"": ""string""}}," + CR
sSwagger += " {""name"": ""limit"", ""in"": ""query"", ""schema"": {""type"": ""integer""}}," + CR
sSwagger += " {""name"": ""offset"", ""in"": ""query"", ""schema"": {""type"": ""integer""}}" + CR
sSwagger += " ]," + CR
sSwagger += " ""responses"": {" + CR
sSwagger += " ""200"": {""description"": ""Lista de registros""}" + CR
sSwagger += " }" + CR
sSwagger += " }," + CR

// POST Create
sSwagger += " ""post"": {" + CR
sSwagger += " ""summary"": ""Criar novo registro""," + CR
sSwagger += " ""requestBody"": {" + CR
sSwagger += " ""content"": {" + CR
sSwagger += " ""application/json"": {" + CR
sSwagger += " ""schema"": " + GenerateJSONSchema(stFields) + CR
sSwagger += " }" + CR
sSwagger += " }" + CR
sSwagger += " }," + CR
sSwagger += " ""responses"": {" + CR
sSwagger += " ""201"": {""description"": ""Registro criado""}" + CR
sSwagger += " }" + CR
sSwagger += " }" + CR
sSwagger += " }" + CR

sSwagger += " }" + CR
sSwagger += "}" + CR

RESULT sSwagger
```

END

//——————————————————————————
// GenerateJSONSchema: Gera schema JSON para documentação
//——————————————————————————
PROCEDURE STATIC GenerateJSONSchema(stFields is array of stFieldInfo) : string
sSchema is string
i is int

```
sSchema = "{" + CR + " ""type"": ""object""," + CR + " ""properties"": {" + CR

FOR i = 1 TO ArrayCount(stFields)
IF i > 1 THEN
sSchema += "," + CR
END

sSchema += " """ + stFields[i].sName + """: {" + CR
sSchema += " ""type"": """ + GetJSONType(stFields[i].nType) + """" + CR

IF stFields[i].bMandatory THEN
sSchema += "," + CR + " ""required"": true" + CR
END

sSchema += " }"
END

sSchema += CR + " }" + CR + "}"

RESULT sSchema
```

END

//——————————————————————————
// GetJSONType: Converte tipo HFSQL para tipo JSON
//——————————————————————————
PROCEDURE STATIC GetJSONType(nHFSQLType is int) : string
SWITCH nHFSQLType
CASE hItemText, hItemMemo, hItemBinaryMemo
RESULT “string”
CASE hItemNumeric, hItemReal, hItemCurrency
RESULT “number”
CASE hItemBoolean
RESULT “boolean”
CASE hItemDate, hItemTime, hItemDateTime
RESULT “string”
DEFAULT
RESULT “string”
END
END

//——————————————————————————
// ValidateJSON: Valida estrutura JSON contra schema da tabela
//——————————————————————————
PROCEDURE STATIC ValidateJSON(sJSON is string, stFields is array of stFieldInfo) : boolean
varData is Variant
i is int

```
TRY
JSONToVariant(varData, sJSON)

// Valida cada campo obrigatório
FOR i = 1 TO ArrayCount(stFields)
IF stFields[i].bMandatory THEN
IF NOT VariantExists(varData, stFields[i].sName) THEN
RESULT False
END
END
END

RESULT True

EXCEPTION
RESULT False
END
```

END

//==============================================================================
// EXEMPLO COMPLETO DE USO DO SISTEMA
//==============================================================================

/*
//——————————————————————————
// EXEMPLO 1: Uso básico - Uma tabela
//——————————————————————————

// Servidor
serverCliente is CRestCRUDServer(“Cliente”)
serverCliente.StartServer(8080)

// Cliente
clienteAPI is CRestCRUDClient(“http://localhost:8080/api/v1”, “cliente”)

// Operações
novoCliente is Variant
novoCliente.nome = “Maria Silva”
novoCliente.email = “maria@teste.com”
resultado is Variant = clienteAPI.Create(novoCliente)

//——————————————————————————
// EXEMPLO 2: Uso avançado - Múltiplas tabelas
//——————————————————————————

// Gerenciador para todas as tabelas
manager is CRestCRUDManager()

// Inicia servidores para todas as tabelas descobertas
manager.StartAllServers()

// Gera documentação
sDocumentacao is string = manager.GetAPIDocumentation()
fSaveText(“c:\temp\api_docs.md”, sDocumentacao)

//——————————————————————————
// EXEMPLO 3: Geração de código cliente
//——————————————————————————

// Gera código cliente específico para tabela Cliente
sCodigoCliente is string = CRestCRUDHelper.GenerateClientCode(“Cliente”, “http://localhost:8080/api/v1”)
fSaveText(“c:\temp\CClienteAPI.wl”, sCodigoCliente)

// Gera documentação Swagger
stCampos is array of stFieldInfo
// … preenche campos …
sSwagger is string = CRestCRUDHelper.GenerateSwaggerDoc(“Cliente”, stCampos)
fSaveText(“c:\temp\swagger.json”, sSwagger)

//——————————————————————————
// EXEMPLO 4: API com Query SQL personalizada
//——————————————————————————

sQueryPersonalizada is string = “SELECT c.nome, c.email, p.descricao as perfil “ + …
“FROM Cliente c INNER JOIN Perfil p ON c.id_perfil = p.id “ + …
“WHERE c.ativo = 1”

serverQuery is CRestCRUDServer(sQueryPersonalizada)
serverQuery.StartServer(8081, “/api/v1”)

//——————————————————————————
// EXEMPLO 5: Cliente com autenticação
//——————————————————————————

clienteSeguro is CRestCRUDClient(“https://api.empresa.com/v1”, “cliente”, “seu_token_jwt_aqui”)
clienteSeguro.SetTimeout(60000) // 60 segundos

dados is Variant = clienteSeguro.GetAll(“ativo=1”, 50, 0)
*/

servidor is CRestCRUDServer("MinhaTabela")
servidor.StartServer(8080)

cliente is CRestCRUDClient("http://localhost:8080/api/v1", "minhatabela")
dados is Variant = cliente.GetAll()

manager is CRestCRUDManager()
manager.StartAllServers() // Inicia API para TODAS as tabelas

servidor is CRestCRUDServer("Cliente")
servidor.StartServer(8080)

manager is CRestCRUDManager()
manager.StartAllServers() // API para TODAS as tabelas!

clienteAPI is CRestCRUDClient("https://api.empresa.com/v1", "cliente", "token_jwt")
dados is Variant = clienteAPI.GetAll()

//==============================================================================
// EXEMPLO COMPLETO: SISTEMA DE PEDIDOS E ITENS
// Descrição: Demonstra uso prático com relacionamentos mestre-detalhe
// Tabelas: PEDIDO, ITEM_PEDIDO, CLIENTE, PRODUTO
// Autor: Sistema Automático
// Data: 14/08/2025
//==============================================================================

//==============================================================================
// ESTRUTURA DAS TABELAS (Para referência)
//==============================================================================
/*
CLIENTE:

- id (Numeric, Primary Key, Auto Increment)
- nome (Text 100, Mandatory)
- email (Text 150, Mandatory, Unique)
- telefone (Text 20)
- endereco (Text 200)
- cidade (Text 50)
- ativo (Boolean, Default True)

PRODUTO:

- id (Numeric, Primary Key, Auto Increment)
- nome (Text 100, Mandatory)
- descricao (Text 500)
- preco (Currency, Mandatory)
- estoque (Numeric, Default 0)
- categoria (Text 50)
- ativo (Boolean, Default True)

PEDIDO:

- id (Numeric, Primary Key, Auto Increment)
- id_cliente (Numeric, Foreign Key -> CLIENTE.id, Mandatory)
- data_pedido (Date, Mandatory, Default Today)
- hora_pedido (Time, Default Now)
- status (Text 20, Default “PENDENTE”) // PENDENTE, CONFIRMADO, ENVIADO, ENTREGUE, CANCELADO
- valor_total (Currency, Default 0)
- observacoes (Text 500)
- data_entrega (Date)

ITEM_PEDIDO:

- id (Numeric, Primary Key, Auto Increment)
- id_pedido (Numeric, Foreign Key -> PEDIDO.id, Mandatory)
- id_produto (Numeric, Foreign Key -> PRODUTO.id, Mandatory)
- quantidade (Numeric, Mandatory, Default 1)
- preco_unitario (Currency, Mandatory)
- preco_total (Currency, Calculated: quantidade * preco_unitario)
- observacoes (Text 200)
*/

//==============================================================================
// SERVIDOR: INICIALIZANDO APIS PARA TODAS AS TABELAS
//==============================================================================

PROCEDURE IniciarServidorPedidos()
// Gerenciador para todas as tabelas do sistema
manager is CRestCRUDManager()

```
Info("🚀 Iniciando Sistema de Pedidos - APIs REST")

// Exibe documentação das tabelas encontradas
sDoc is string = manager.GetAPIDocumentation()
Trace("📋 Tabelas do sistema:" + CR + sDoc)

// Inicia servidores para todas as tabelas
IF manager.StartAllServers() THEN
Info("✅ Servidor de Pedidos iniciado com sucesso!" + CR + CR + ...
"🌐 APIs disponíveis:" + CR + ...
"• CLIENTE: http://localhost:8080/api/v1/cliente" + CR + ...
"• PRODUTO: http://localhost:8081/api/v1/produto" + CR + ...
"• PEDIDO: http://localhost:8082/api/v1/pedido" + CR + ...
"• ITEM_PEDIDO: http://localhost:8083/api/v1/item_pedido" + CR + CR + ...
"📖 Consulte API_Documentation.md para detalhes")

// Mantém servidores ativos
Info("⚡ Servidores rodando... Pressione OK para parar.")
ELSE
Error("❌ Falha ao iniciar servidores!")
END
```

END

//==============================================================================
// CLASSE: CPedidoManager
// Descrição: Gerenciador de alto nível para operações de pedidos
//==============================================================================

CPedidoManager is Class
PRIVATE
m_cClienteAPI is CRestCRUDClient
m_cProdutoAPI is CRestCRUDClient
m_cPedidoAPI is CRestCRUDClient
m_cItemPedidoAPI is CRestCRUDClient
m_sBaseURL is string
END

//——————————————————————————
// Constructor: Inicializa todos os clientes API
//——————————————————————————
PROCEDURE Constructor(sBaseURL is string = “http://localhost”)
m_sBaseURL = sBaseURL

```
// Inicializa clientes para cada tabela
m_cClienteAPI = new CRestCRUDClient(sBaseURL + ":8080/api/v1", "cliente")
m_cProdutoAPI = new CRestCRUDClient(sBaseURL + ":8081/api/v1", "produto")
m_cPedidoAPI = new CRestCRUDClient(sBaseURL + ":8082/api/v1", "pedido")
m_cItemPedidoAPI = new CRestCRUDClient(sBaseURL + ":8083/api/v1", "item_pedido")

// Timeout de 60 segundos para operações complexas
m_cClienteAPI.SetTimeout(60000)
m_cProdutoAPI.SetTimeout(60000)
m_cPedidoAPI.SetTimeout(60000)
m_cItemPedidoAPI.SetTimeout(60000)
```

END

//==============================================================================
// MÉTODOS DE NEGÓCIO - PEDIDOS COMPLETOS
//==============================================================================

//——————————————————————————
// CriarPedidoCompleto: Cria pedido com itens em uma transação
//——————————————————————————
PROCEDURE CriarPedidoCompleto(varPedidoCompleto is Variant) : Variant
varPedidoCriado is Variant
varResult is Variant
arrayItens is array of Variant
nValorTotal is currency = 0
i is int

```
TRY
Trace("🛒 Iniciando criação de pedido completo...")

// 1. Valida se cliente existe
varCliente is Variant = m_cClienteAPI.GetByID(varPedidoCompleto.id_cliente)
IF VariantToJSON(varCliente) = "null" THEN
ExceptionThrow(1, "Cliente não encontrado: " + varPedidoCompleto.id_cliente)
END

Trace("✅ Cliente validado: " + varCliente.nome)

// 2. Valida produtos e calcula valor total
IF VariantExists(varPedidoCompleto, "itens") THEN
arrayItens = varPedidoCompleto.itens

FOR i = 1 TO ArrayCount(arrayItens)
// Valida produto
varProduto is Variant = m_cProdutoAPI.GetByID(arrayItens[i].id_produto)
IF VariantToJSON(varProduto) = "null" THEN
ExceptionThrow(2, "Produto não encontrado: " + arrayItens[i].id_produto)
END

// Valida estoque
IF varProduto.estoque < arrayItens[i].quantidade THEN
ExceptionThrow(3, "Estoque insuficiente para produto: " + varProduto.nome +
" (Disponível: " + varProduto.estoque +
", Solicitado: " + arrayItens[i].quantidade + ")")
END

// Usa preço atual do produto se não informado
IF NOT VariantExists(arrayItens[i], "preco_unitario") THEN
arrayItens[i].preco_unitario = varProduto.preco
END

// Calcula preço total do item
arrayItens[i].preco_total = arrayItens[i].quantidade * arrayItens[i].preco_unitario
nValorTotal += arrayItens[i].preco_total

Trace("✅ Item validado: " + varProduto.nome +
" (Qtd: " + arrayItens[i].quantidade +
", Valor: " + arrayItens[i].preco_total + ")")
END
END

// 3. Cria o pedido (cabeçalho)
varNovoPedido is Variant
varNovoPedido.id_cliente = varPedidoCompleto.id_cliente
varNovoPedido.data_pedido = IIF(VariantExists(varPedidoCompleto, "data_pedido"),
varPedidoCompleto.data_pedido,
DateToString(Today(), "YYYY-MM-DD"))
varNovoPedido.hora_pedido = IIF(VariantExists(varPedidoCompleto, "hora_pedido"),
varPedidoCompleto.hora_pedido,
TimeToString(Now(), "HH:MM:SS"))
varNovoPedido.status = IIF(VariantExists(varPedidoCompleto, "status"),
varPedidoCompleto.status,
"PENDENTE")
varNovoPedido.valor_total = nValorTotal
varNovoPedido.observacoes = IIF(VariantExists(varPedidoCompleto, "observacoes"),
varPedidoCompleto.observacoes,
"")

varPedidoCriado = m_cPedidoAPI.Create(varNovoPedido)

Trace("✅ Pedido criado - ID: " + varPedidoCriado.id + ", Valor: " + varPedidoCriado.valor_total)

// 4. Cria os itens do pedido
arrayItensCriados is array of Variant

FOR i = 1 TO ArrayCount(arrayItens)
varNovoItem is Variant
varNovoItem.id_pedido = varPedidoCriado.id
varNovoItem.id_produto = arrayItens[i].id_produto
varNovoItem.quantidade = arrayItens[i].quantidade
varNovoItem.preco_unitario = arrayItens[i].preco_unitario
varNovoItem.preco_total = arrayItens[i].preco_total
varNovoItem.observacoes = IIF(VariantExists(arrayItens[i], "observacoes"),
arrayItens[i].observacoes,
"")

varItemCriado is Variant = m_cItemPedidoAPI.Create(varNovoItem)
ArrayAdd(arrayItensCriados, varItemCriado)

// Atualiza estoque do produto
AtualizarEstoque(arrayItens[i].id_produto, -arrayItens[i].quantidade)

Trace("✅ Item criado - ID: " + varItemCriado.id +
", Produto: " + arrayItens[i].id_produto +
", Quantidade: " + arrayItens[i].quantidade)
END

// 5. Monta resultado completo
varResult.pedido = varPedidoCriado
varResult.itens = arrayItensCriados
varResult.cliente = varCliente
varResult.resumo.total_itens = ArrayCount(arrayItensCriados)
varResult.resumo.valor_total = nValorTotal

Trace("🎉 Pedido completo criado com sucesso!")

RESULT varResult

EXCEPTION
Error("❌ Erro ao criar pedido: " + ExceptionInfo())

// Se houve erro e pedido foi criado, tenta cancelar
IF VariantExists(varPedidoCriado, "id") THEN
CancelarPedido(varPedidoCriado.id, "Erro durante criação")
END

RESULT Null
END
```

END

//——————————————————————————
// ObterPedidoCompleto: Busca pedido com todos os dados relacionados
//——————————————————————————
PROCEDURE ObterPedidoCompleto(sIDPedido is string) : Variant
varResult is Variant
varPedido is Variant
varCliente is Variant
arrayItens is array of Variant
arrayItensDetalhados is array of Variant
i is int

```
TRY
// 1. Busca dados do pedido
varPedido = m_cPedidoAPI.GetByID(sIDPedido)
IF VariantToJSON(varPedido) = "null" THEN
ExceptionThrow(1, "Pedido não encontrado: " + sIDPedido)
END

// 2. Busca dados do cliente
varCliente = m_cClienteAPI.GetByID(varPedido.id_cliente)

// 3. Busca itens do pedido
arrayItens = m_cItemPedidoAPI.GetAll("id_pedido=" + sIDPedido)

// 4. Enriquece itens com dados dos produtos
FOR i = 1 TO ArrayCount(arrayItens)
varItemDetalhado is Variant = arrayItens[i]

// Busca dados do produto
varProduto is Variant = m_cProdutoAPI.GetByID(arrayItens[i].id_produto)

// Adiciona informações do produto ao item
varItemDetalhado.produto_nome = varProduto.nome
varItemDetalhado.produto_descricao = varProduto.descricao
varItemDetalhado.produto_categoria = varProduto.categoria
varItemDetalhado.produto_estoque_atual = varProduto.estoque

ArrayAdd(arrayItensDetalhados, varItemDetalhado)
END

// 5. Monta resultado completo
varResult.pedido = varPedido
varResult.cliente = varCliente
varResult.itens = arrayItensDetalhados
varResult.resumo.total_itens = ArrayCount(arrayItensDetalhados)
varResult.resumo.valor_total = varPedido.valor_total

RESULT varResult

EXCEPTION
Error("❌ Erro ao obter pedido completo: " + ExceptionInfo())
RESULT Null
END
```

END

//——————————————————————————
// AtualizarStatusPedido: Atualiza status do pedido
//——————————————————————————
PROCEDURE AtualizarStatusPedido(sIDPedido is string, sNovoStatus is string, sObservacao is string = “”) : boolean
varDados is Variant

```
TRY
varDados.status = sNovoStatus

IF sObservacao <> "" THEN
// Busca observações atuais
varPedido is Variant = m_cPedidoAPI.GetByID(sIDPedido)
sObservacaoAtual is string = IIF(VariantExists(varPedido, "observacoes"), varPedido.observacoes, "")

// Adiciona nova observação com timestamp
sTimestamp is string = DateTimeToString(Now(), "DD/MM/YYYY HH:MM:SS")
varDados.observacoes = sObservacaoAtual + CR + "[" + sTimestamp + "] Status: " + sNovoStatus + " - " + sObservacao
END

varAtualizado is Variant = m_cPedidoAPI.Update(sIDPedido, varDados)

Trace("✅ Status do pedido " + sIDPedido + " atualizado para: " + sNovoStatus)
RESULT True

EXCEPTION
Error("❌ Erro ao atualizar status: " + ExceptionInfo())
RESULT False
END
```

END

//——————————————————————————
// CancelarPedido: Cancela pedido e reverte estoque
//——————————————————————————
PROCEDURE CancelarPedido(sIDPedido is string, sMotivo is string = “”) : boolean
arrayItens is array of Variant
i is int

```
TRY
// 1. Busca itens do pedido para reverter estoque
arrayItens = m_cItemPedidoAPI.GetAll("id_pedido=" + sIDPedido)

// 2. Reverte estoque de cada item
FOR i = 1 TO ArrayCount(arrayItens)
AtualizarEstoque(arrayItens[i].id_produto, arrayItens[i].quantidade)
Trace("↩️ Estoque revertido - Produto: " + arrayItens[i].id_produto + ", Qtd: " + arrayItens[i].quantidade)
END

// 3. Atualiza status do pedido
sObservacaoCancelamento is string = "Pedido cancelado"
IF sMotivo <> "" THEN
sObservacaoCancelamento += " - Motivo: " + sMotivo
END

RESULT AtualizarStatusPedido(sIDPedido, "CANCELADO", sObservacaoCancelamento)

EXCEPTION
Error("❌ Erro ao cancelar pedido: " + ExceptionInfo())
RESULT False
END
```

END

//==============================================================================
// MÉTODOS AUXILIARES
//==============================================================================

//——————————————————————————
// AtualizarEstoque: Atualiza estoque do produto
//——————————————————————————
PRIVATE PROCEDURE AtualizarEstoque(sIDProduto is string, nQuantidade is int) : boolean
TRY
// Busca produto atual
varProduto is Variant = m_cProdutoAPI.GetByID(sIDProduto)

```
// Calcula novo estoque
nNovoEstoque is int = varProduto.estoque + nQuantidade

IF nNovoEstoque < 0 THEN
ExceptionThrow(1, "Estoque não pode ficar negativo")
END

// Atualiza estoque
varDados is Variant
varDados.estoque = nNovoEstoque

m_cProdutoAPI.Update(sIDProduto, varDados)

Trace("📦 Estoque atualizado - Produto: " + sIDProduto +
", Anterior: " + varProduto.estoque +
", Novo: " + nNovoEstoque)

RESULT True

EXCEPTION
Error("❌ Erro ao atualizar estoque: " + ExceptionInfo())
RESULT False
END
```

END

//——————————————————————————
// ListarPedidosPorCliente: Lista pedidos de um cliente
//——————————————————————————
PROCEDURE ListarPedidosPorCliente(sIDCliente is string, sStatus is string = “”) : Variant
sFilter is string = “id_cliente=” + sIDCliente

```
IF sStatus <> "" THEN
sFilter += " AND status='" + sStatus + "'"
END

RESULT m_cPedidoAPI.GetAll(sFilter, 100, 0)
```

END

//——————————————————————————
// ListarPedidosPorPeriodo: Lista pedidos por período
//——————————————————————————
PROCEDURE ListarPedidosPorPeriodo(dDataInicio is Date, dDataFim is Date) : Variant
sFilter is string = StringBuild(“data_pedido>=’%1’ AND data_pedido<=’%2’”,
DateToString(dDataInicio, “YYYY-MM-DD”),
DateToString(dDataFim, “YYYY-MM-DD”))

```
RESULT m_cPedidoAPI.GetAll(sFilter, 1000, 0)
```

END

//==============================================================================
// EXEMPLO DE USO PRÁTICO
//==============================================================================

PROCEDURE TestarSistemaPedidos()
// Inicializa gerenciador
pedidoManager is CPedidoManager()

```
Info("🧪 Iniciando teste do Sistema de Pedidos...")

TRY
//----------------------------------------------------------------------
// 1. CRIAR DADOS DE TESTE
//----------------------------------------------------------------------
Info("📝 Criando dados de teste...")

// Criar cliente de teste
novoCliente is Variant
novoCliente.nome = "João Silva"
novoCliente.email = "joao.teste@email.com"
novoCliente.telefone = "11999887766"
novoCliente.endereco = "Rua das Flores, 123"
novoCliente.cidade = "São Paulo"

clienteCriado is Variant = pedidoManager.m_cClienteAPI.Create(novoCliente)
sIDCliente is string = clienteCriado.id

// Criar produtos de teste
arrayProdutosCriados is array of string

FOR i = 1 TO 3
novoProduto is Variant
novoProduto.nome = "Produto Teste " + i
novoProduto.descricao = "Descrição do produto " + i
novoProduto.preco = 25.50 * i
novoProduto.estoque = 100
novoProduto.categoria = "Eletrônicos"

produtoCriado is Variant = pedidoManager.m_cProdutoAPI.Create(novoProduto)
ArrayAdd(arrayProdutosCriados, produtoCriado.id)
END

Info("✅ Dados de teste criados - Cliente: " + sIDCliente + ", Produtos: " + ArrayCount(arrayProdutosCriados))

//----------------------------------------------------------------------
// 2. CRIAR PEDIDO COMPLETO
//----------------------------------------------------------------------
Info("🛒 Criando pedido completo...")

pedidoCompleto is Variant
pedidoCompleto.id_cliente = sIDCliente
pedidoCompleto.observacoes = "Pedido de teste criado via API"

// Itens do pedido
arrayItens is array of Variant

FOR i = 1 TO ArrayCount(arrayProdutosCriados)
novoItem is Variant
novoItem.id_produto = arrayProdutosCriados[i]
novoItem.quantidade = i * 2 // 2, 4, 6
novoItem.observacoes = "Item " + i + " do pedido de teste"

ArrayAdd(arrayItens, novoItem)
END

pedidoCompleto.itens = arrayItens

// Cria pedido
resultadoPedido is Variant = pedidoManager.CriarPedidoCompleto(pedidoCompleto)
sIDPedido is string = resultadoPedido.pedido.id

sResumo is string = StringBuild("✅ Pedido criado com sucesso!" + CR +
"• ID: %1" + CR +
"• Cliente: %2" + CR +
"• Total de itens: %3" + CR +
"• Valor total: R$ %4",
sIDPedido,
resultadoPedido.cliente.nome,
resultadoPedido.resumo.total_itens,
resultadoPedido.resumo.valor_total)
Info(sResumo)

//----------------------------------------------------------------------
// 3. CONSULTAR PEDIDO COMPLETO
//----------------------------------------------------------------------
Info("🔍 Consultando pedido completo...")

pedidoDetalhado is Variant = pedidoManager.ObterPedidoCompleto(sIDPedido)

sDetalhes is string = "📋 Detalhes do Pedido:" + CR + CR
sDetalhes += "Cliente: " + pedidoDetalhado.cliente.nome + " (" + pedidoDetalhado.cliente.email + ")" + CR
sDetalhes += "Data: " + pedidoDetalhado.pedido.data_pedido + " " + pedidoDetalhado.pedido.hora_pedido + CR
sDetalhes += "Status: " + pedidoDetalhado.pedido.status + CR
sDetalhes += "Valor Total: R$ " + pedidoDetalhado.pedido.valor_total + CR + CR
sDetalhes += "📦 Itens:" + CR

FOR i = 1 TO ArrayCount(pedidoDetalhado.itens)
sDetalhes += StringBuild("• %1 (Qtd: %2, Preço: R$ %3, Total: R$ %4)" + CR,
pedidoDetalhado.itens[i].produto_nome,
pedidoDetalhado.itens[i].quantidade,
pedidoDetalhado.itens[i].preco_unitario,
pedidoDetalhado.itens[i].preco_total)
END

Info(sDetalhes)

//----------------------------------------------------------------------
// 4. ATUALIZAR STATUS DO PEDIDO
//----------------------------------------------------------------------
Info("📝 Atualizando status do pedido...")

IF pedidoManager.AtualizarStatusPedido(sIDPedido, "CONFIRMADO", "Pedido confirmado após verificação") THEN
Info("✅ Status atualizado para CONFIRMADO")
END

IF pedidoManager.AtualizarStatusPedido(sIDPedido, "ENVIADO", "Pedido enviado via transportadora XYZ") THEN
Info("✅ Status atualizado para ENVIADO")
END

//----------------------------------------------------------------------
// 5. LISTAR PEDIDOS DO CLIENTE
//----------------------------------------------------------------------
Info("📋 Listando pedidos do cliente...")

pedidosCliente is Variant = pedidoManager.ListarPedidosPorCliente(sIDCliente)
Info("📊 Cliente possui " + ArrayCount(pedidosCliente) + " pedido(s)")

//----------------------------------------------------------------------
// 6. CANCELAR PEDIDO (OPCIONAL)
//----------------------------------------------------------------------
nResposta is int = YesNo("❓ Deseja cancelar o pedido de teste?")

IF nResposta = Yes THEN
IF pedidoManager.CancelarPedido(sIDPedido, "Teste concluído") THEN
Info("✅ Pedido cancelado e estoque revertido")
END
END

//----------------------------------------------------------------------
// 7. LIMPEZA DOS DADOS DE TESTE
//----------------------------------------------------------------------
IF YesNo("🗑️ Excluir dados de teste criados?") = Yes THEN
Info("🗑️ Removendo dados de teste...")

// Remove itens do pedido
itensPedido is Variant = pedidoManager.m_cItemPedidoAPI.GetAll("id_pedido=" + sIDPedido)
FOR i = 1 TO ArrayCount(itensPedido)
pedidoManager.m_cItemPedidoAPI.Delete(itensPedido[i].id)
END

// Remove pedido
pedidoManager.m_cPedidoAPI.Delete(sIDPedido)

// Remove produtos
FOR i = 1 TO ArrayCount(arrayProdutosCriados)
pedidoManager.m_cProdutoAPI.Delete(arrayProdutosCriados[i])
END

// Remove cliente
pedidoManager.m_cClienteAPI.Delete(sIDCliente)

Info("✅ Dados de teste removidos")
END

EXCEPTION
Error("❌ Erro durante teste: " + ExceptionInfo())
END

Info("🎉 Teste do Sistema de Pedidos concluído!")
```

END

//==============================================================================
// RELATÓRIOS E CONSULTAS AVANÇADAS
//==============================================================================

//——————————————————————————
// GerarRelatorioPedidos: Gera relatório consolidado de pedidos
//——————————————————————————
PROCEDURE GerarRelatorioPedidos(dDataInicio is Date, dDataFim is Date) : string
pedidoManager is CPedidoManager()
sRelatorio is string

```
TRY
// Busca pedidos do período
pedidosPeriodo is Variant = pedidoManager.ListarPedidosPorPeriodo(dDataInicio, dDataFim)

nTotalPedidos is int = ArrayCount(pedidosPeriodo)
nValorTotal is currency = 0
nPendentes is int = 0
nConfirmados is int = 0
nEnviados is int = 0
nEntregues is int = 0
nCancelados is int = 0

// Analisa dados
FOR i = 1 TO nTotalPedidos
nValorTotal += pedidosPeriodo[i].valor_total

SWITCH pedidosPeriodo[i].status
CASE "PENDENTE": nPendentes++
CASE "CONFIRMADO": nConfirmados++
CASE "ENVIADO": nEnviados++
CASE "ENTREGUE": nEntregues++
CASE "CANCELADO": nCancelados++
END
END

// Gera relatório
sRelatorio = "📊 RELATÓRIO DE PEDIDOS" + CR
sRelatorio += "Período: " + DateToString(dDataInicio, "DD/MM/YYYY") + " a " + DateToString(dDataFim, "DD/MM/YYYY") + CR
sRelatorio += StringRepeat("=", 50) + CR + CR

sRelatorio += "📈 RESUMO GERAL:" + CR
sRelatorio += "• Total de pedidos: " + nTotalPedidos + CR
sRelatorio += "• Valor total: R$ " + NumToString(nValorTotal, "999,999.99") + CR
sRelatorio += "• Ticket médio: R$ " + IIF(nTotalPedidos > 0, NumToString(nValorTotal / nTotalPedidos, "999.99"), "0.00") + CR + CR

sRelatorio += "📊 STATUS DOS PEDIDOS:" + CR
sRelatorio += "• Pendentes: " + nPendentes + " (" + NumToString(nPendentes * 100 / nTotalPedidos, "99.9") + "%)" + CR
sRelatorio += "• Confirmados: " + nConfirmados + " (" + NumToString(nConfirmados *
```