# FASE 3: FLUJO EMPRESARIAL

**Complejidad:** Media
**Duración estimada:** 1-2 días
**Prioridad:** MEDIA

---

## OBJETIVO

Desplegar MARGARET en CORP (clon de CLARA para servidor empresarial).

---

## PREREQUISITOS

- [x] FASE 1 completada (CLARA funcionando)
- [ ] SSH acceso a CORP (92.112.181.188)
- [ ] PostgreSQL en CORP accesible
- [ ] R2 bucket 'corp' accesible

---

## PASO 3.1: Crear repo margaret con código

MARGARET es esencialmente CLARA con:
- Diferente h_instancia
- Bucket R2 'corp' en lugar de 'deck'
- Tabla margaret_log en lugar de clara_log
- Campos adicionales para empresas (opcional)

### Script

```bash
#!/bin/bash
# Crear MARGARET como fork de CLARA

SSH_KEY="/home/orchestrator/.ssh/tzzr"
WORK_DIR="/tmp/create-margaret"

rm -rf $WORK_DIR
mkdir -p $WORK_DIR
cd $WORK_DIR

# Clonar CLARA
GIT_SSH_COMMAND="ssh -i $SSH_KEY -p 2222" \
  git clone ssh://git@localhost:2222/tzzr/clara.git margaret

cd margaret

# Renombrar referencias
find . -type f -name "*.py" -exec sed -i 's/clara/margaret/g' {} \;
find . -type f -name "*.py" -exec sed -i 's/CLARA/MARGARET/g' {} \;
find . -type f -name "*.md" -exec sed -i 's/clara/margaret/g' {} \;
find . -type f -name "*.md" -exec sed -i 's/CLARA/MARGARET/g' {} \;
find . -type f -name "*.md" -exec sed -i 's/DECK/CORP/g' {} \;

# Actualizar docker-compose.yml
sed -i 's/5051/5052/g' docker-compose.yml
sed -i 's/deck/corp/g' docker-compose.yml

# Actualizar README
cat > README.md << 'EOF'
![Estado](https://img.shields.io/badge/Estado-IMPLEMENTADO-green)

# MARGARET

**Log de entrada CORP - Sistema TZZR**

Clon de CLARA para servidor empresarial. Recibe contenedores de PACKET y los almacena en PostgreSQL + R2.

## Diferencias con CLARA

| Aspecto | CLARA | MARGARET |
|---------|-------|----------|
| Servidor | DECK | CORP |
| Puerto | 5051 | 5052 |
| Bucket R2 | deck | corp |
| Tabla | clara_log | margaret_log |

## Despliegue

```bash
cd /opt/margaret
cp .env.example .env
# Editar .env con credenciales
docker-compose up -d
```

## API

Idéntica a CLARA:
- `POST /ingest` - Recibir contenedor
- `GET /query/{h_entrada}` - Consultar por hash
- `GET /list` - Listar entradas
- `GET /health` - Health check
EOF

# Cambiar origen remoto
git remote set-url origin ssh://git@localhost:2222/tzzr/margaret.git

# Crear nuevo historial
rm -rf .git
git init
git add -A
git commit -m "MARGARET: fork de CLARA para CORP"

# Push (asumiendo que el repo ya existe vacío)
GIT_SSH_COMMAND="ssh -i $SSH_KEY -p 2222" git push -u origin main --force
```

---

## PASO 3.2: Crear tablas en CORP PostgreSQL

### Conectar a CORP

```bash
ssh -i /home/orchestrator/.ssh/tzzr root@92.112.181.188
```

### Crear base de datos si no existe

```bash
sudo -u postgres psql << 'EOF'
CREATE DATABASE corp;
CREATE USER margaret WITH PASSWORD 'margaret_secure_2024';
GRANT ALL PRIVILEGES ON DATABASE corp TO margaret;
EOF
```

### Crear tabla

```bash
sudo -u postgres psql -d corp << 'EOF'

CREATE TABLE IF NOT EXISTS margaret_log (
    id BIGSERIAL PRIMARY KEY,
    h_instancia VARCHAR(64) NOT NULL,
    h_entrada VARCHAR(64) NOT NULL,
    contenedor JSONB NOT NULL,
    r2_paths JSONB DEFAULT '{}',
    estado VARCHAR(20) DEFAULT 'recibido',
    -- Campos adicionales para empresas
    empresa_id VARCHAR(64),
    proyecto_id VARCHAR(64),
    aprobado_por VARCHAR(100),
    procesado_at TIMESTAMP,
    created_at TIMESTAMP DEFAULT NOW(),
    CONSTRAINT margaret_log_h_entrada_unique UNIQUE (h_entrada)
);

CREATE INDEX idx_margaret_h_instancia ON margaret_log(h_instancia);
CREATE INDEX idx_margaret_empresa ON margaret_log(empresa_id);
CREATE INDEX idx_margaret_proyecto ON margaret_log(proyecto_id);
CREATE INDEX idx_margaret_created ON margaret_log(created_at DESC);

COMMENT ON TABLE margaret_log IS 'Log de entrada CORP - contenedores empresariales';
EOF
```

---

## PASO 3.3: Desplegar MARGARET

### En CORP

```bash
ssh -i /home/orchestrator/.ssh/tzzr root@92.112.181.188 << 'REMOTE'

mkdir -p /opt/margaret
cd /opt/margaret

# Clonar repo
git clone http://69.62.126.110:3000/tzzr/margaret.git .

# Generar h_instancia único para CORP
SEED="corp-enterprise-$(hostname)-$(date +%s)"
H_INSTANCIA=$(echo -n "$SEED" | sha256sum | cut -d' ' -f1)

# Crear .env
cat > .env << EOF
H_INSTANCIA=$H_INSTANCIA

# PostgreSQL
DB_HOST=localhost
DB_PORT=5432
DB_NAME=corp
DB_USER=margaret
DB_PASSWORD=margaret_secure_2024

# R2
R2_ENDPOINT=https://7dedae6030f5554d99d37e98a5232996.r2.cloudflarestorage.com
R2_ACCESS_KEY=ecddc771824c3cb3417d9451780db3d2
R2_SECRET_KEY=c8138e2597100ffb7dd1477ad722c0214f86097cd968752aea3cfcea5d54dbac
R2_BUCKET=corp

PORT=5052
EOF

# Construir y levantar
docker-compose up -d --build

REMOTE
```

---

## PASO 3.4: Configurar Caddy en CORP

```bash
ssh -i /home/orchestrator/.ssh/tzzr root@92.112.181.188 << 'REMOTE'

cat >> /etc/caddy/Caddyfile << 'EOF'

margaret.tzzrcorp.me {
    reverse_proxy localhost:5052
}
EOF

systemctl reload caddy

REMOTE
```

---

## PASO 3.5: Probar ingesta

```bash
H_INSTANCIA="<hash_generado_en_corp>"

curl -X POST http://92.112.181.188:5052/ingest \
  -H "Content-Type: application/json" \
  -H "X-Auth-Key: $H_INSTANCIA" \
  -d '{
    "id": "test-corp-001",
    "archivo_hash": "test-corp-hash-001",
    "origen": {"app": "test"},
    "empresa_id": "empresa-001",
    "proyecto_id": "proyecto-alpha"
  }'
```

---

## CHECKLIST FINAL FASE 3

- [ ] 3.1 - Repo margaret creado con código
- [ ] 3.2 - Tabla margaret_log creada
- [ ] 3.3 - MARGARET corriendo en Docker
- [ ] 3.4 - Caddy configurado
- [ ] 3.5 - Test de ingesta exitoso

---

## SIGUIENTE FASE

Continuar con [FASE_4_PIPELINE_COMPLETO.md](FASE_4_PIPELINE_COMPLETO.md)