Mapa de Processos
API & Dados

// 1. Separar dados por tipo de endpoint
const appItems  = items.filter(i => i.application && !i.activityEmployeeID);
const siteItems = items.filter(i => i.activityEmployeeID);
const groups    = items.filter(i => i.clientGroupID);

// 2. Agrupar appItems por (employeeName + startDate) → sessões
const sessions = {};
for (const row of appItems) {
  const key = `${row.employeeName}|${row.startDate}`;
  if (!sessions[key]) sessions[key] = [];
  sessions[key].push(row.application);
}

// 3. Acumular minutos por app → nós
const appMinutes = {};
for (const row of appItems) {
  appMinutes[row.application] = (appMinutes[row.application] || 0) + row.totalMinutes;
}

// 4. Contar co-ocorrências → arestas
const edgeMap = {};
for (const apps of Object.values(sessions)) {
  for (let i = 0; i < apps.length; i++) {
    for (let j = i + 1; j < apps.length; j++) {
      const key = [apps[i], apps[j]].sort().join('|');
      edgeMap[key] = (edgeMap[key] || 0) + 1;
    }
  }
}

// 5. Montar nodes e edges para vis-network
const nodeIndex = {};
const nodes = Object.entries(appMinutes).map(([app, mins], idx) => {
  nodeIndex[app] = idx + 1;
  return { id: idx + 1, label: app, value: mins };
});

const edges = Object.entries(edgeMap).map(([key, weight], idx) => {
  const [a, b] = key.split('|');
  return { id: idx + 1, from: nodeIndex[a], to: nodeIndex[b], value: weight };
});

curl -X POST https://webhook.digital-ai.tech/webhook/evope/processmap \
  -H "Content-Type: application/json" \
  -H "X-Auth-Token: <seu-token>" \
  -d '{
    "DateIni": "2026-07-07",
    "DateEnd": "2026-07-14",
    "ClientGroupId": "",
    "SearchSubgroups": true
  }'

const response = await fetch(
  'https://webhook.digital-ai.tech/webhook/evope/processmap',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'X-Auth-Token': '' },
    body: JSON.stringify({
      DateIni: '2026-07-07',
      DateEnd: '2026-07-14',
      ClientGroupId: '',
      SearchSubgroups: true
    })
  }
);

const data = await response.json();

console.log(`Nodes: ${data.stats.totalNodes}`);
console.log(`Edges: ${data.stats.totalEdges}`);
console.log(`Employees: ${data.stats.totalEmployees}`);

import requests

response = requests.post(
    "https://webhook.digital-ai.tech/webhook/evope/processmap",
    headers={"X-Auth-Token": ""},
    json={
        "DateIni": "2026-07-07",
        "DateEnd": "2026-07-14",
        "ClientGroupId": "",
        "SearchSubgroups": True
    }
)

data = response.json()
nodes = data["graph"]["nodes"]
edges = data["graph"]["edges"]

print(f"Nodes: {len(nodes)}, Edges: {len(edges)}")

import requests
from itertools import combinations
from collections import defaultdict

BASE_URL = "https://openrest.evope.com.br/api/v0"
EMAIL    = "seu-email@evope.com.br"
PASSWD   = "sua-senha"

def build_processmap(date_ini: str, date_end: str, group_id: str = ""):
    # 1. Autenticar
    token = requests.post(f"{BASE_URL}/auth", json={
        "email": EMAIL, "password": PASSWD
    }).json()["token"]
    headers = {"Authorization": f"Bearer {token}"}

    # 2. Buscar dados em paralelo (aqui sequencial para simplicidade)
    app_data = requests.post(f"{BASE_URL}/applicationreport", headers=headers, json={
        "DateIni": date_ini, "DateEnd": date_end,
        "ClientGroupId": group_id, "SearchSubgroups": True
    }).json()

    # Sitereport usa DataIni/DataFim e formato DD/MM/YYYY
    from datetime import datetime
    d1 = datetime.strptime(date_ini, "%Y-%m-%d").strftime("%d/%m/%Y")
    d2 = datetime.strptime(date_end, "%Y-%m-%d").strftime("%d/%m/%Y")
    site_data = requests.post(f"{BASE_URL}/sitereport", headers=headers, json={
        "DataIni": d1, "DataFim": d2
    }).json()

    groups = requests.get(f"{BASE_URL}/ClientGroup/", headers=headers).json()

    # 3. Construir grafo
    sessions = defaultdict(list)
    app_minutes = defaultdict(int)
    for row in app_data:
        key = f"{row['employeeName']}|{row['startDate']}"
        sessions[key].append(row["application"])
        app_minutes[row["application"]] += row.get("totalMinutes", 0)

    edge_count = defaultdict(int)
    for apps in sessions.values():
        for a, b in combinations(sorted(set(apps)), 2):
            edge_count[(a, b)] += 1

    node_index = {}
    nodes = []
    for i, (app, mins) in enumerate(app_minutes.items(), 1):
        node_index[app] = i
        nodes.append({"id": i, "label": app, "value": mins,
                      "title": f"{app}\n{mins} min total"})

    edges = []
    for j, ((a, b), weight) in enumerate(edge_count.items(), 1):
        if a in node_index and b in node_index:
            edges.append({"id": j, "from": node_index[a],
                          "to": node_index[b], "value": weight,
                          "title": f"Usados juntos: {weight}x"})

    return {
        "graph": {"nodes": nodes, "edges": edges},
        "stats": {
            "totalNodes": len(nodes), "totalEdges": len(edges),
            "totalGroups": len(groups)
        }
    }

# Uso
result = build_processmap("2026-07-07", "2026-07-14")
print(f"Nodes: {result['stats']['totalNodes']}")
print(f"Edges: {result['stats']['totalEdges']}")