263 lines
9.6 KiB
TypeScript
263 lines
9.6 KiB
TypeScript
import tls from "tls"
|
|
|
|
import { action, mutation, query } from "./_generated/server"
|
|
import { api } from "./_generated/api"
|
|
import { v } from "convex/values"
|
|
import type { Id } from "./_generated/dataModel"
|
|
|
|
// Minimal SMTP client (AUTH LOGIN over implicit TLS)
|
|
function b64(input: string) {
|
|
return Buffer.from(input, "utf8").toString("base64")
|
|
}
|
|
|
|
async function sendSmtpMail(cfg: { host: string; port: number; username: string; password: string; from: string }, to: string, subject: string, html: string) {
|
|
return new Promise<void>((resolve, reject) => {
|
|
const socket = tls.connect(cfg.port, cfg.host, { rejectUnauthorized: false }, () => {
|
|
let buffer = ""
|
|
const send = (line: string) => socket.write(line + "\r\n")
|
|
const wait = (expected: string | RegExp) =>
|
|
new Promise<void>((res) => {
|
|
const onData = (data: Buffer) => {
|
|
buffer += data.toString()
|
|
const lines = buffer.split(/\r?\n/)
|
|
const last = lines.filter(Boolean).slice(-1)[0] ?? ""
|
|
if (typeof expected === "string" ? last.startsWith(expected) : expected.test(last)) {
|
|
socket.removeListener("data", onData)
|
|
res()
|
|
}
|
|
}
|
|
socket.on("data", onData)
|
|
socket.on("error", reject)
|
|
})
|
|
|
|
;(async () => {
|
|
await wait(/^220 /)
|
|
send(`EHLO ${cfg.host}`)
|
|
await wait(/^250-/)
|
|
await wait(/^250 /)
|
|
send("AUTH LOGIN")
|
|
await wait(/^334 /)
|
|
send(b64(cfg.username))
|
|
await wait(/^334 /)
|
|
send(b64(cfg.password))
|
|
await wait(/^235 /)
|
|
send(`MAIL FROM:<${cfg.from.match(/<(.+)>/)?.[1] ?? cfg.from}>`)
|
|
await wait(/^250 /)
|
|
send(`RCPT TO:<${to}>`)
|
|
await wait(/^250 /)
|
|
send("DATA")
|
|
await wait(/^354 /)
|
|
const headers = [
|
|
`From: ${cfg.from}`,
|
|
`To: ${to}`,
|
|
`Subject: ${subject}`,
|
|
"MIME-Version: 1.0",
|
|
"Content-Type: text/html; charset=UTF-8",
|
|
].join("\r\n")
|
|
send(headers + "\r\n\r\n" + html + "\r\n.")
|
|
await wait(/^250 /)
|
|
send("QUIT")
|
|
socket.end()
|
|
resolve()
|
|
})().catch(reject)
|
|
})
|
|
socket.on("error", reject)
|
|
})
|
|
}
|
|
|
|
export const log = mutation({
|
|
args: {
|
|
tenantId: v.string(),
|
|
companyId: v.optional(v.id("companies")),
|
|
companyName: v.string(),
|
|
usagePct: v.number(),
|
|
threshold: v.number(),
|
|
range: v.string(),
|
|
recipients: v.array(v.string()),
|
|
deliveredCount: v.number(),
|
|
},
|
|
handler: async (ctx, args) => {
|
|
const now = Date.now()
|
|
await ctx.db.insert("alerts", {
|
|
tenantId: args.tenantId,
|
|
companyId: args.companyId,
|
|
companyName: args.companyName,
|
|
usagePct: args.usagePct,
|
|
threshold: args.threshold,
|
|
range: args.range,
|
|
recipients: args.recipients,
|
|
deliveredCount: args.deliveredCount,
|
|
createdAt: now,
|
|
})
|
|
},
|
|
})
|
|
|
|
export const list = query({
|
|
args: {
|
|
tenantId: v.string(),
|
|
viewerId: v.id("users"),
|
|
limit: v.optional(v.number()),
|
|
companyId: v.optional(v.id("companies")),
|
|
start: v.optional(v.number()),
|
|
end: v.optional(v.number()),
|
|
},
|
|
handler: async (ctx, { tenantId, viewerId, limit, companyId, start, end }) => {
|
|
// Only admins can see the full alerts log
|
|
const user = await ctx.db.get(viewerId)
|
|
if (!user || user.tenantId !== tenantId || (user.role ?? "").toUpperCase() !== "ADMIN") {
|
|
return []
|
|
}
|
|
let items = await ctx.db
|
|
.query("alerts")
|
|
.withIndex("by_tenant", (q) => q.eq("tenantId", tenantId))
|
|
.collect()
|
|
if (companyId) items = items.filter((a) => a.companyId === companyId)
|
|
if (typeof start === "number") items = items.filter((a) => a.createdAt >= start)
|
|
if (typeof end === "number") items = items.filter((a) => a.createdAt < end)
|
|
return items
|
|
.sort((a, b) => b.createdAt - a.createdAt)
|
|
.slice(0, Math.max(1, Math.min(limit ?? 200, 500)))
|
|
},
|
|
})
|
|
|
|
export const managersForCompany = query({
|
|
args: { tenantId: v.string(), companyId: v.id("companies") },
|
|
handler: async (ctx, { tenantId, companyId }) => {
|
|
const users = await ctx.db
|
|
.query("users")
|
|
.withIndex("by_tenant_company", (q) => q.eq("tenantId", tenantId).eq("companyId", companyId))
|
|
.collect()
|
|
return users.filter((u) => (u.role ?? "").toUpperCase() === "MANAGER")
|
|
},
|
|
})
|
|
|
|
export const lastForCompanyBySlug = query({
|
|
args: { tenantId: v.string(), slug: v.string() },
|
|
handler: async (ctx, { tenantId, slug }) => {
|
|
const company = await ctx.db
|
|
.query("companies")
|
|
.withIndex("by_tenant_slug", (q) => q.eq("tenantId", tenantId).eq("slug", slug))
|
|
.first()
|
|
if (!company) return null
|
|
const items = await ctx.db
|
|
.query("alerts")
|
|
.withIndex("by_tenant", (q) => q.eq("tenantId", tenantId))
|
|
.collect()
|
|
const matches = items.filter((a) => a.companyId === company._id)
|
|
if (matches.length === 0) return null
|
|
const last = matches.sort((a, b) => b.createdAt - a.createdAt)[0]
|
|
return { createdAt: last.createdAt, usagePct: last.usagePct, threshold: last.threshold }
|
|
},
|
|
})
|
|
|
|
export const tenantIds = query({
|
|
args: {},
|
|
handler: async (ctx) => {
|
|
const companies = await ctx.db.query("companies").collect()
|
|
return Array.from(new Set(companies.map((c) => c.tenantId)))
|
|
},
|
|
})
|
|
|
|
export const existsForCompanyRange = query({
|
|
args: { tenantId: v.string(), companyId: v.id("companies"), start: v.number(), end: v.number() },
|
|
handler: async (ctx, { tenantId, companyId, start, end }) => {
|
|
const items = await ctx.db
|
|
.query("alerts")
|
|
.withIndex("by_tenant", (q) => q.eq("tenantId", tenantId))
|
|
.collect()
|
|
return items.some((a) => a.companyId === companyId && a.createdAt >= start && a.createdAt < end)
|
|
},
|
|
})
|
|
|
|
export const sendHoursUsageAlerts = action({
|
|
args: { range: v.optional(v.string()), threshold: v.optional(v.number()) },
|
|
handler: async (ctx, { range, threshold }) => {
|
|
const R = (range ?? "30d") as string
|
|
const T = typeof threshold === "number" ? threshold : 90
|
|
|
|
const smtp = {
|
|
host: process.env.SMTP_ADDRESS!,
|
|
port: Number(process.env.SMTP_PORT ?? 465),
|
|
username: process.env.SMTP_USERNAME!,
|
|
password: process.env.SMTP_PASSWORD!,
|
|
from: process.env.MAILER_SENDER_EMAIL || "no-reply@example.com",
|
|
}
|
|
if (!smtp.host || !smtp.username || !smtp.password) {
|
|
console.warn("SMTP not configured; skipping alerts send")
|
|
return { sent: 0 }
|
|
}
|
|
|
|
const targetHour = Number(process.env.ALERTS_LOCAL_HOUR ?? 8)
|
|
const now = new Date()
|
|
const fmt = new Intl.DateTimeFormat("en-CA", { timeZone: "America/Sao_Paulo", year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit", hour12: false })
|
|
const parts = Object.fromEntries(fmt.formatToParts(now).map((p) => [p.type, p.value])) as Record<string, string>
|
|
const hourSP = Number(parts.hour)
|
|
if (hourSP !== targetHour) {
|
|
return { skipped: true, reason: "hour_guard" }
|
|
}
|
|
|
|
const dayKey = `${parts.year}-${parts.month}-${parts.day}`
|
|
// compute start/end of Sao Paulo day in UTC milliseconds
|
|
const startSP = new Date(`${dayKey}T00:00:00-03:00`).getTime()
|
|
const endSP = startSP + 24 * 60 * 60 * 1000
|
|
|
|
const tenants = await ctx.runQuery(api.alerts.tenantIds, {})
|
|
let totalSent = 0
|
|
|
|
for (const tenantId of tenants) {
|
|
const report = await ctx.runQuery(api.reports.hoursByClientInternal, { tenantId, range: R })
|
|
type Item = {
|
|
companyId: Id<"companies">
|
|
name: string
|
|
internalMs: number
|
|
externalMs: number
|
|
totalMs: number
|
|
contractedHoursPerMonth: number | null
|
|
}
|
|
const items = (report.items ?? []) as Item[]
|
|
const candidates = items.filter((i) => i.contractedHoursPerMonth != null && (i.totalMs / 3600000) / (i.contractedHoursPerMonth || 1) * 100 >= T)
|
|
|
|
for (const item of candidates) {
|
|
const already = await ctx.runQuery(api.alerts.existsForCompanyRange, { tenantId, companyId: item.companyId, start: startSP, end: endSP })
|
|
if (already) continue
|
|
const managers = await ctx.runQuery(api.alerts.managersForCompany, { tenantId, companyId: item.companyId })
|
|
if (managers.length === 0) continue
|
|
const usagePct = (((item.totalMs / 3600000) / (item.contractedHoursPerMonth || 1)) * 100)
|
|
const subject = `Alerta: uso de horas em ${item.name} acima de ${T}%`
|
|
const body = `
|
|
<p>Olá,</p>
|
|
<p>O uso de horas contratadas para <strong>${item.name}</strong> atingiu <strong>${usagePct.toFixed(1)}%</strong>.</p>
|
|
<ul>
|
|
<li>Horas internas: <strong>${(item.internalMs/3600000).toFixed(2)}</strong></li>
|
|
<li>Horas externas: <strong>${(item.externalMs/3600000).toFixed(2)}</strong></li>
|
|
<li>Total: <strong>${(item.totalMs/3600000).toFixed(2)}</strong></li>
|
|
<li>Contratadas/mês: <strong>${item.contractedHoursPerMonth}</strong></li>
|
|
</ul>
|
|
<p>Reveja a alocação da equipe e, se necessário, ajuste o atendimento.</p>
|
|
`
|
|
let delivered = 0
|
|
for (const m of managers) {
|
|
try {
|
|
await sendSmtpMail(smtp, m.email, subject, body)
|
|
delivered += 1
|
|
} catch (error) {
|
|
console.error("Failed to send alert to", m.email, error)
|
|
}
|
|
}
|
|
totalSent += delivered
|
|
await ctx.runMutation(api.alerts.log, {
|
|
tenantId,
|
|
companyId: item.companyId,
|
|
companyName: item.name,
|
|
usagePct,
|
|
threshold: T,
|
|
range: R,
|
|
recipients: managers.map((m) => m.email),
|
|
deliveredCount: delivered,
|
|
})
|
|
}
|
|
}
|
|
|
|
return { sent: totalSent }
|
|
},
|
|
})
|