SDKs e Exemplos

class MeuPonto360 {
  constructor(apiKey, baseUrl = 'https://api.meuponto360.com/v1') {
    this.baseUrl = baseUrl;
    this.headers = {
      'x-api-key': apiKey,
      'Content-Type': 'application/json',
    };
  }

  async request(method, path, body) {
    const res = await fetch(`${this.baseUrl}${path}`, {
      method,
      headers: this.headers,
      body: body ? JSON.stringify(body) : undefined,
    });

    if (!res.ok) {
      const err = await res.json().catch(() => ({}));
      throw Object.assign(new Error(err.message ?? 'API Error'), { status: res.status });
    }

    return res.status === 204 ? null : res.json();
  }

  // Colaboradores
  listEmployees(params = {}) {
    const q = new URLSearchParams(params).toString();
    return this.request('GET', `/employees?${q}`);
  }

  createEmployee(data) { return this.request('POST', '/employees', data); }
  updateEmployee(id, data) { return this.request('PATCH', `/employees/${id}`, data); }

  // Ponto
  registerPunch(employeeId, type, timestamp) {
    return this.request('POST', '/time-entries', { employeeId, type, timestamp });
  }

  listTimeEntries(params = {}) {
    const q = new URLSearchParams(params).toString();
    return this.request('GET', `/time-entries?${q}`);
  }

  // Relatórios
  getPeriodReport(start, end) {
    return this.request('GET', `/reports/period?start=${start}&end=${end}`);
  }
}

// Uso:
const mp = new MeuPonto360('mp360_sk_sua_chave');

const employees = await mp.listEmployees({ status: 'ACTIVE' });
await mp.registerPunch(employees.data[0].id, 'ENTRY');

import requests
from datetime import datetime

class MeuPonto360:
    BASE_URL = 'https://api.meuponto360.com/v1'

    def __init__(self, api_key: str):
        self.session = requests.Session()
        self.session.headers.update({'x-api-key': api_key})

    def _request(self, method, path, **kwargs):
        resp = self.session.request(method, f'{self.BASE_URL}{path}', **kwargs)
        resp.raise_for_status()
        return resp.json() if resp.content else None

    # Colaboradores
    def list_employees(self, **params):
        return self._request('GET', '/employees', params=params)

    def create_employee(self, **data):
        return self._request('POST', '/employees', json=data)

    def update_employee(self, employee_id, **data):
        return self._request('PATCH', f'/employees/{employee_id}', json=data)

    # Ponto
    def register_punch(self, employee_id, punch_type, timestamp=None):
        payload = {'employeeId': employee_id, 'type': punch_type}
        if timestamp:
            payload['timestamp'] = timestamp.isoformat()
        return self._request('POST', '/time-entries', json=payload)

    def list_time_entries(self, **params):
        return self._request('GET', '/time-entries', params=params)

    # Relatórios
    def get_period_report(self, start: str, end: str):
        return self._request('GET', '/reports/period', params={'start': start, 'end': end})


# Uso:
mp = MeuPonto360('mp360_sk_sua_chave')

employees = mp.list_employees(status='ACTIVE')
mp.register_punch(employees['data'][0]['id'], 'ENTRY', datetime.now())

import MeuPonto360 from './meuponto360.js';

const mp = new MeuPonto360(process.env.MP360_API_KEY);

async function syncEmployees(erpEmployees) {
  // Carregar cadastro atual
  const { data: existing } = await mp.listEmployees({ limit: 200 });
  const existingByReg = new Map(
    existing.map(e => [e.registrationNumber, e])
  );

  const results = { created: 0, updated: 0, errors: [] };

  for (const emp of erpEmployees) {
    try {
      const current = existingByReg.get(emp.matricula);

      if (!current) {
        // Criar novo colaborador
        await mp.createEmployee({
          name: emp.nome,
          registrationNumber: emp.matricula,
          email: emp.email,
          admissionDate: emp.dataAdmissao,
        });
        results.created++;
      } else if (current.email !== emp.email) {
        // Atualizar e-mail se mudou
        await mp.updateEmployee(current.id, { email: emp.email });
        results.updated++;
      }
    } catch (err) {
      results.errors.push({ matricula: emp.matricula, error: err.message });
    }
  }

  console.log(`Sync concluído: ${results.created} criados, ${results.updated} atualizados`);
  if (results.errors.length > 0) {
    console.error('Erros:', results.errors);
  }
}

// Executar
const erpData = [
  { matricula: '001', nome: 'João Silva', email: 'joao@empresa.com', dataAdmissao: '2024-01-15' },
  { matricula: '002', nome: 'Maria Santos', email: 'maria@empresa.com', dataAdmissao: '2025-03-01' },
];

await syncEmployees(erpData);

// Endpoint que recebe eventos do terminal de acesso
app.post('/webhook/access-terminal', async (req, res) => {
  const { badgeId, direction, timestamp } = req.body;
  // direction: 'in' | 'out' (formato do terminal externo)

  try {
    // Converter matrícula do crachá para employeeId do MeuPonto360
    const employee = await db.employees.findByBadgeId(badgeId);

    if (!employee?.mp360Id) {
      return res.status(404).json({ error: 'Colaborador não mapeado' });
    }

    // Registrar ponto
    await mp.registerPunch(
      employee.mp360Id,
      direction === 'in' ? 'ENTRY' : 'EXIT',
      new Date(timestamp).toISOString()
    );

    res.json({ success: true });
  } catch (err) {
    console.error('Erro ao registrar ponto:', err);
    res.status(500).json({ error: err.message });
  }
});