2import { NextResponse } from 'next/server'

3export async function POST(req: Request) {

4 const { email } = await req.json()

5 return NextResponse.json({ ok: true })

8const useStack = <T,>(): Stack<T> => {

9 const [items, setItems] = useState<T[]>([])

10 const push = (item: T) => setItems(p => [...p, item])

11 return { items, push }

12}

14class FacturaElectronica(models.Model):

15 cufe = models.CharField(max_length=96, unique=True)

16 prefijo = models.CharField(max_length=4)

17 consecutivo = models.PositiveIntegerField()

18 total = models.DecimalField(max_digits=18, decimal_places=2)

20SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

21FROM usuarios u

22LEFT JOIN pedidos p ON p.usuario_id = u.id

23WHERE u.activo = true GROUP BY u.id;

25{

26 "servicio": "halu-medic",

27 "version": "2.4.1",

28 "runtime": "python3.12",

29 "region": "us-east-1"

30}

32const App: FC = () => (

33 <Layout>

34 <Hero />

35 <Services />

36 </Layout>

37)

39@app.route('/api/facturas', methods=['POST'])

40def crear_factura():

41 data = request.get_json()

42 return jsonify(servicio.crear(data))

44interface Cliente {

45 id: string

46 nombre: string

47 nit: string

48 activo: boolean

49}

51docker compose up -d --build

52nginx -s reload

53pytest tests/ -v --cov=app

54npm run build && npm run start

56await celery.send_task('rips.procesar', args=[batch_id])

57cache.set(key, value, timeout=3600)

59import { NextResponse } from 'next/server'

60export async function POST(req: Request) {

61 const { email } = await req.json()

62 return NextResponse.json({ ok: true })

63}

65const useStack = <T,>(): Stack<T> => {

66 const [items, setItems] = useState<T[]>([])

67 const push = (item: T) => setItems(p => [...p, item])

68 return { items, push }

69}

71class FacturaElectronica(models.Model):

72 cufe = models.CharField(max_length=96, unique=True)

73 prefijo = models.CharField(max_length=4)

74 consecutivo = models.PositiveIntegerField()

75 total = models.DecimalField(max_digits=18, decimal_places=2)

77SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

78FROM usuarios u

79LEFT JOIN pedidos p ON p.usuario_id = u.id

80WHERE u.activo = true GROUP BY u.id;

82{

83 "servicio": "halu-medic",

84 "version": "2.4.1",

85 "runtime": "python3.12",

86 "region": "us-east-1"

87}

89const App: FC = () => (

90 <Layout>

91 <Hero />

92 <Services />

93 </Layout>

94)

96@app.route('/api/facturas', methods=['POST'])

97def crear_factura():

98 data = request.get_json()

99 return jsonify(servicio.crear(data))

100

101interface Cliente {

102 id: string

103 nombre: string

104 nit: string

105 activo: boolean

106}

107

108docker compose up -d --build

109nginx -s reload

110pytest tests/ -v --cov=app

111npm run build && npm run start

112

113await celery.send_task('rips.procesar', args=[batch_id])

114cache.set(key, value, timeout=3600)

115

43import { NextResponse } from 'next/server'

44export async function POST(req: Request) {

45 const { email } = await req.json()

46 return NextResponse.json({ ok: true })

47}

49const useStack = <T,>(): Stack<T> => {

50 const [items, setItems] = useState<T[]>([])

51 const push = (item: T) => setItems(p => [...p, item])

52 return { items, push }

53}

55class FacturaElectronica(models.Model):

56 cufe = models.CharField(max_length=96, unique=True)

57 prefijo = models.CharField(max_length=4)

58 consecutivo = models.PositiveIntegerField()

59 total = models.DecimalField(max_digits=18, decimal_places=2)

61SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

62FROM usuarios u

63LEFT JOIN pedidos p ON p.usuario_id = u.id

64WHERE u.activo = true GROUP BY u.id;

66{

67 "servicio": "halu-medic",

68 "version": "2.4.1",

69 "runtime": "python3.12",

70 "region": "us-east-1"

71}

73const App: FC = () => (

74 <Layout>

75 <Hero />

76 <Services />

77 </Layout>

78)

80@app.route('/api/facturas', methods=['POST'])

81def crear_factura():

82 data = request.get_json()

83 return jsonify(servicio.crear(data))

85interface Cliente {

86 id: string

87 nombre: string

88 nit: string

89 activo: boolean

90}

92docker compose up -d --build

93nginx -s reload

94pytest tests/ -v --cov=app

95npm run build && npm run start

97await celery.send_task('rips.procesar', args=[batch_id])

98cache.set(key, value, timeout=3600)

100import { NextResponse } from 'next/server'

101export async function POST(req: Request) {

102 const { email } = await req.json()

103 return NextResponse.json({ ok: true })

104}

105

106const useStack = <T,>(): Stack<T> => {

107 const [items, setItems] = useState<T[]>([])

108 const push = (item: T) => setItems(p => [...p, item])

109 return { items, push }

110}

111

112class FacturaElectronica(models.Model):

113 cufe = models.CharField(max_length=96, unique=True)

114 prefijo = models.CharField(max_length=4)

115 consecutivo = models.PositiveIntegerField()

116 total = models.DecimalField(max_digits=18, decimal_places=2)

117

118SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

119FROM usuarios u

120LEFT JOIN pedidos p ON p.usuario_id = u.id

121WHERE u.activo = true GROUP BY u.id;

122

123{

124 "servicio": "halu-medic",

125 "version": "2.4.1",

126 "runtime": "python3.12",

127 "region": "us-east-1"

128}

129

130const App: FC = () => (

131 <Layout>

132 <Hero />

133 <Services />

134 </Layout>

135)

136

137@app.route('/api/facturas', methods=['POST'])

138def crear_factura():

139 data = request.get_json()

140 return jsonify(servicio.crear(data))

141

142interface Cliente {

143 id: string

144 nombre: string

145 nit: string

146 activo: boolean

147}

148

149docker compose up -d --build

150nginx -s reload

151pytest tests/ -v --cov=app

152npm run build && npm run start

153

154await celery.send_task('rips.procesar', args=[batch_id])

155cache.set(key, value, timeout=3600)

156

85import { NextResponse } from 'next/server'

86export async function POST(req: Request) {

87 const { email } = await req.json()

88 return NextResponse.json({ ok: true })

89}

91const useStack = <T,>(): Stack<T> => {

92 const [items, setItems] = useState<T[]>([])

93 const push = (item: T) => setItems(p => [...p, item])

94 return { items, push }

95}

97class FacturaElectronica(models.Model):

98 cufe = models.CharField(max_length=96, unique=True)

99 prefijo = models.CharField(max_length=4)

100 consecutivo = models.PositiveIntegerField()

101 total = models.DecimalField(max_digits=18, decimal_places=2)

102

103SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

104FROM usuarios u

105LEFT JOIN pedidos p ON p.usuario_id = u.id

106WHERE u.activo = true GROUP BY u.id;

107

108{

109 "servicio": "halu-medic",

110 "version": "2.4.1",

111 "runtime": "python3.12",

112 "region": "us-east-1"

113}

114

115const App: FC = () => (

116 <Layout>

117 <Hero />

118 <Services />

119 </Layout>

120)

121

122@app.route('/api/facturas', methods=['POST'])

123def crear_factura():

124 data = request.get_json()

125 return jsonify(servicio.crear(data))

126

127interface Cliente {

128 id: string

129 nombre: string

130 nit: string

131 activo: boolean

132}

133

134docker compose up -d --build

135nginx -s reload

136pytest tests/ -v --cov=app

137npm run build && npm run start

138

139await celery.send_task('rips.procesar', args=[batch_id])

140cache.set(key, value, timeout=3600)

141

142import { NextResponse } from 'next/server'

143export async function POST(req: Request) {

144 const { email } = await req.json()

145 return NextResponse.json({ ok: true })

146}

147

148const useStack = <T,>(): Stack<T> => {

149 const [items, setItems] = useState<T[]>([])

150 const push = (item: T) => setItems(p => [...p, item])

151 return { items, push }

152}

153

154class FacturaElectronica(models.Model):

155 cufe = models.CharField(max_length=96, unique=True)

156 prefijo = models.CharField(max_length=4)

157 consecutivo = models.PositiveIntegerField()

158 total = models.DecimalField(max_digits=18, decimal_places=2)

159

160SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

161FROM usuarios u

162LEFT JOIN pedidos p ON p.usuario_id = u.id

163WHERE u.activo = true GROUP BY u.id;

164

165{

166 "servicio": "halu-medic",

167 "version": "2.4.1",

168 "runtime": "python3.12",

169 "region": "us-east-1"

170}

171

172const App: FC = () => (

173 <Layout>

174 <Hero />

175 <Services />

176 </Layout>

177)

178

179@app.route('/api/facturas', methods=['POST'])

180def crear_factura():

181 data = request.get_json()

182 return jsonify(servicio.crear(data))

183

184interface Cliente {

185 id: string

186 nombre: string

187 nit: string

188 activo: boolean

189}

190

191docker compose up -d --build

192nginx -s reload

193pytest tests/ -v --cov=app

194npm run build && npm run start

195

196await celery.send_task('rips.procesar', args=[batch_id])

197cache.set(key, value, timeout=3600)

198

127import { NextResponse } from 'next/server'

128export async function POST(req: Request) {

129 const { email } = await req.json()

130 return NextResponse.json({ ok: true })

131}

132

133const useStack = <T,>(): Stack<T> => {

134 const [items, setItems] = useState<T[]>([])

135 const push = (item: T) => setItems(p => [...p, item])

136 return { items, push }

137}

138

139class FacturaElectronica(models.Model):

140 cufe = models.CharField(max_length=96, unique=True)

141 prefijo = models.CharField(max_length=4)

142 consecutivo = models.PositiveIntegerField()

143 total = models.DecimalField(max_digits=18, decimal_places=2)

144

145SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

146FROM usuarios u

147LEFT JOIN pedidos p ON p.usuario_id = u.id

148WHERE u.activo = true GROUP BY u.id;

149

150{

151 "servicio": "halu-medic",

152 "version": "2.4.1",

153 "runtime": "python3.12",

154 "region": "us-east-1"

155}

156

157const App: FC = () => (

158 <Layout>

159 <Hero />

160 <Services />

161 </Layout>

162)

163

164@app.route('/api/facturas', methods=['POST'])

165def crear_factura():

166 data = request.get_json()

167 return jsonify(servicio.crear(data))

168

169interface Cliente {

170 id: string

171 nombre: string

172 nit: string

173 activo: boolean

174}

175

176docker compose up -d --build

177nginx -s reload

178pytest tests/ -v --cov=app

179npm run build && npm run start

180

181await celery.send_task('rips.procesar', args=[batch_id])

182cache.set(key, value, timeout=3600)

183

184import { NextResponse } from 'next/server'

185export async function POST(req: Request) {

186 const { email } = await req.json()

187 return NextResponse.json({ ok: true })

188}

189

190const useStack = <T,>(): Stack<T> => {

191 const [items, setItems] = useState<T[]>([])

192 const push = (item: T) => setItems(p => [...p, item])

193 return { items, push }

194}

195

196class FacturaElectronica(models.Model):

197 cufe = models.CharField(max_length=96, unique=True)

198 prefijo = models.CharField(max_length=4)

199 consecutivo = models.PositiveIntegerField()

200 total = models.DecimalField(max_digits=18, decimal_places=2)

201

202SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

203FROM usuarios u

204LEFT JOIN pedidos p ON p.usuario_id = u.id

205WHERE u.activo = true GROUP BY u.id;

206

207{

208 "servicio": "halu-medic",

209 "version": "2.4.1",

210 "runtime": "python3.12",

211 "region": "us-east-1"

212}

213

214const App: FC = () => (

215 <Layout>

216 <Hero />

217 <Services />

218 </Layout>

219)

220

221@app.route('/api/facturas', methods=['POST'])

222def crear_factura():

223 data = request.get_json()

224 return jsonify(servicio.crear(data))

225

226interface Cliente {

227 id: string

228 nombre: string

229 nit: string

230 activo: boolean

231}

232

233docker compose up -d --build

234nginx -s reload

235pytest tests/ -v --cov=app

236npm run build && npm run start

237

238await celery.send_task('rips.procesar', args=[batch_id])

239cache.set(key, value, timeout=3600)

240

169import { NextResponse } from 'next/server'

170export async function POST(req: Request) {

171 const { email } = await req.json()

172 return NextResponse.json({ ok: true })

173}

174

175const useStack = <T,>(): Stack<T> => {

176 const [items, setItems] = useState<T[]>([])

177 const push = (item: T) => setItems(p => [...p, item])

178 return { items, push }

179}

180

181class FacturaElectronica(models.Model):

182 cufe = models.CharField(max_length=96, unique=True)

183 prefijo = models.CharField(max_length=4)

184 consecutivo = models.PositiveIntegerField()

185 total = models.DecimalField(max_digits=18, decimal_places=2)

186

187SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

188FROM usuarios u

189LEFT JOIN pedidos p ON p.usuario_id = u.id

190WHERE u.activo = true GROUP BY u.id;

191

192{

193 "servicio": "halu-medic",

194 "version": "2.4.1",

195 "runtime": "python3.12",

196 "region": "us-east-1"

197}

198

199const App: FC = () => (

200 <Layout>

201 <Hero />

202 <Services />

203 </Layout>

204)

205

206@app.route('/api/facturas', methods=['POST'])

207def crear_factura():

208 data = request.get_json()

209 return jsonify(servicio.crear(data))

210

211interface Cliente {

212 id: string

213 nombre: string

214 nit: string

215 activo: boolean

216}

217

218docker compose up -d --build

219nginx -s reload

220pytest tests/ -v --cov=app

221npm run build && npm run start

222

223await celery.send_task('rips.procesar', args=[batch_id])

224cache.set(key, value, timeout=3600)

225

226import { NextResponse } from 'next/server'

227export async function POST(req: Request) {

228 const { email } = await req.json()

229 return NextResponse.json({ ok: true })

230}

231

232const useStack = <T,>(): Stack<T> => {

233 const [items, setItems] = useState<T[]>([])

234 const push = (item: T) => setItems(p => [...p, item])

235 return { items, push }

236}

237

238class FacturaElectronica(models.Model):

239 cufe = models.CharField(max_length=96, unique=True)

240 prefijo = models.CharField(max_length=4)

241 consecutivo = models.PositiveIntegerField()

242 total = models.DecimalField(max_digits=18, decimal_places=2)

243

244SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

245FROM usuarios u

246LEFT JOIN pedidos p ON p.usuario_id = u.id

247WHERE u.activo = true GROUP BY u.id;

248

249{

250 "servicio": "halu-medic",

251 "version": "2.4.1",

252 "runtime": "python3.12",

253 "region": "us-east-1"

254}

255

256const App: FC = () => (

257 <Layout>

258 <Hero />

259 <Services />

260 </Layout>

261)

262

263@app.route('/api/facturas', methods=['POST'])

264def crear_factura():

265 data = request.get_json()

266 return jsonify(servicio.crear(data))

267

268interface Cliente {

269 id: string

270 nombre: string

271 nit: string

272 activo: boolean

273}

274

275docker compose up -d --build

276nginx -s reload

277pytest tests/ -v --cov=app

278npm run build && npm run start

279

280await celery.send_task('rips.procesar', args=[batch_id])

281cache.set(key, value, timeout=3600)

282

211import { NextResponse } from 'next/server'

212export async function POST(req: Request) {

213 const { email } = await req.json()

214 return NextResponse.json({ ok: true })

215}

216

217const useStack = <T,>(): Stack<T> => {

218 const [items, setItems] = useState<T[]>([])

219 const push = (item: T) => setItems(p => [...p, item])

220 return { items, push }

221}

222

223class FacturaElectronica(models.Model):

224 cufe = models.CharField(max_length=96, unique=True)

225 prefijo = models.CharField(max_length=4)

226 consecutivo = models.PositiveIntegerField()

227 total = models.DecimalField(max_digits=18, decimal_places=2)

228

229SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

230FROM usuarios u

231LEFT JOIN pedidos p ON p.usuario_id = u.id

232WHERE u.activo = true GROUP BY u.id;

233

234{

235 "servicio": "halu-medic",

236 "version": "2.4.1",

237 "runtime": "python3.12",

238 "region": "us-east-1"

239}

240

241const App: FC = () => (

242 <Layout>

243 <Hero />

244 <Services />

245 </Layout>

246)

247

248@app.route('/api/facturas', methods=['POST'])

249def crear_factura():

250 data = request.get_json()

251 return jsonify(servicio.crear(data))

252

253interface Cliente {

254 id: string

255 nombre: string

256 nit: string

257 activo: boolean

258}

259

260docker compose up -d --build

261nginx -s reload

262pytest tests/ -v --cov=app

263npm run build && npm run start

264

265await celery.send_task('rips.procesar', args=[batch_id])

266cache.set(key, value, timeout=3600)

267

268import { NextResponse } from 'next/server'

269export async function POST(req: Request) {

270 const { email } = await req.json()

271 return NextResponse.json({ ok: true })

272}

273

274const useStack = <T,>(): Stack<T> => {

275 const [items, setItems] = useState<T[]>([])

276 const push = (item: T) => setItems(p => [...p, item])

277 return { items, push }

278}

279

280class FacturaElectronica(models.Model):

281 cufe = models.CharField(max_length=96, unique=True)

282 prefijo = models.CharField(max_length=4)

283 consecutivo = models.PositiveIntegerField()

284 total = models.DecimalField(max_digits=18, decimal_places=2)

285

286SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

287FROM usuarios u

288LEFT JOIN pedidos p ON p.usuario_id = u.id

289WHERE u.activo = true GROUP BY u.id;

290

291{

292 "servicio": "halu-medic",

293 "version": "2.4.1",

294 "runtime": "python3.12",

295 "region": "us-east-1"

296}

297

298const App: FC = () => (

299 <Layout>

300 <Hero />

301 <Services />

302 </Layout>

303)

304

305@app.route('/api/facturas', methods=['POST'])

306def crear_factura():

307 data = request.get_json()

308 return jsonify(servicio.crear(data))

309

310interface Cliente {

311 id: string

312 nombre: string

313 nit: string

314 activo: boolean

315}

316

317docker compose up -d --build

318nginx -s reload

319pytest tests/ -v --cov=app

320npm run build && npm run start

321

322await celery.send_task('rips.procesar', args=[batch_id])

323cache.set(key, value, timeout=3600)

324

AXENTIATECHNOLOGIES

$Hablemos

cd ../inicio

// cookies.md

Política de Cookies

Le explicamos qué son las cookies, cuáles usamos y cómo puede gestionarlas en su navegador.

// Última actualización: 30 de junio de 2026

1. ¿Qué son las cookies?

Las cookies son pequeños archivos de texto que un sitio web guarda en su dispositivo (computador, tablet o móvil) cuando usted lo visita. Sirven para que el sitio funcione correctamente, recuerde sus preferencias y, en algunos casos, recopile información estadística sobre el uso.

2. Tipos de cookies que utilizamos

TipoPropósitoDuración

Estrictamente necesarias

Permiten el funcionamiento básico del sitio (navegación, seguridad). Sin ellas el sitio no opera correctamente.

Sesión

De preferencias

Recuerdan opciones que usted elige (idioma, tema visual) para personalizar su experiencia.

Hasta 1 año

Analíticas

Recolectan información agregada y anónima sobre cómo se usa el sitio (páginas vistas, tiempo de permanencia) para mejorarlo.

Hasta 2 años

De terceros

Provienen de servicios externos integrados (analítica, mapas, video). Cada proveedor tiene su propia política.

Variable

3. Cookies de terceros

Este sitio puede integrar servicios de terceros que instalan sus propias cookies. Las principales que podríamos usar son:

Vercel Analytics / Speed Insights — medición anónima de rendimiento.
Google Analytics (si se activa) — analítica de tráfico agregada.
Cloudflare — seguridad y entrega de contenido.

Le recomendamos revisar las políticas de cada proveedor.

4. ¿Cómo gestionar o desactivar las cookies?

Usted puede aceptar, rechazar o eliminar las cookies desde la configuración de su navegador. Aquí encuentra las guías oficiales:

Si desactiva las cookies estrictamente necesarias, es posible que algunas funciones del sitio no operen correctamente.

5. Consentimiento

Al continuar navegando en este sitio web sin modificar la configuración de su navegador, usted nos otorga su consentimiento para el uso de cookies conforme a esta política. Puede revocarlo en cualquier momento ajustando su navegador.

6. Cambios a esta política

Podremos actualizar esta política de cookies en cualquier momento. La versión vigente siempre estará disponible en esta misma URL con su fecha de actualización.