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

Volver al inicio

Términos y Condiciones

Reglas que rigen el uso de este sitio web y la prestación de servicios por parte de Axentia Technologies.

Última actualización: 30 de junio de 2026

1. Aceptación

El acceso y uso de este sitio web implica la aceptación plena y sin reservas de los presentes Términos y Condiciones. Si no está de acuerdo con alguno de ellos, le solicitamos no continuar usando el sitio.

2. Identificación del prestador

Axentia Technologies, empresa colombiana de desarrollo de software con sede en Sabanalarga y Barranquilla, Atlántico. Contacto: contacto@axentiatechnologies.com · +57 324 686 8538.

3. Servicios ofrecidos

A través de este sitio web, Axentia Technologies ofrece servicios profesionales de:

Diseño y desarrollo de páginas web institucionales y landing pages.
Construcción de software web a medida y aplicaciones SaaS.
Integraciones con APIs externas y facturación electrónica (DIAN).
Mantenimiento, soporte técnico y SEO.
Servicios derivados del ecosistema Halu Group.

El alcance específico de cada proyecto se define por contrato o cotización formal.

4. Uso del sitio web

El usuario se compromete a:

Usar el sitio conforme a la ley, la moral y el orden público.
No realizar actividades que puedan dañar, sobrecargar o deteriorar el sitio.
No intentar acceder a áreas restringidas ni vulnerar las medidas de seguridad.
No reproducir, copiar o distribuir contenido del sitio sin autorización expresa.

5. Propiedad intelectual

Todos los contenidos del sitio (textos, gráficos, logos, código fuente, animaciones, productos del ecosistema Halu) son propiedad de Axentia Technologies o cuentan con licencia para su uso, y están protegidos por las leyes colombianas e internacionales de propiedad intelectual. Queda prohibida su reproducción total o parcial sin autorización escrita.

6. Cotizaciones, contratación y pagos

Las cotizaciones publicadas o entregadas tienen una vigencia máxima de 30 días calendario, salvo indicación distinta.
La prestación de servicios se formaliza mediante contrato u orden de servicio firmada por ambas partes.
Las condiciones de pago, hitos, entregables y plazos serán los pactados en cada contrato.
Salvo acuerdo en contrario, los pagos se realizan en pesos colombianos (COP) más los impuestos aplicables.

7. Garantías y soporte

Axentia Technologies garantiza el correcto funcionamiento del software entregado conforme al alcance contractual. Los servicios de soporte, mantenimiento y SLA se acuerdan por separado en cada proyecto.

8. Limitación de responsabilidad

Axentia Technologies no será responsable por daños indirectos, lucro cesante o pérdidas derivadas del mal uso del sitio web o del software entregado, ni por interrupciones causadas por terceros (proveedores de hosting, redes, etc.), fuerza mayor o caso fortuito.

9. Enlaces a terceros

Este sitio puede contener enlaces a sitios externos. No nos hacemos responsables por el contenido, políticas o prácticas de privacidad de dichos sitios.

10. Modificaciones

Axentia Technologies se reserva el derecho de modificar estos términos en cualquier momento. Los cambios serán publicados en este mismo lugar con su fecha de actualización y aplicarán a partir de su publicación.

11. Legislación aplicable y jurisdicción

Estos términos se rigen por las leyes de la República de Colombia. Cualquier controversia derivada del uso del sitio o de la prestación de servicios se someterá a los jueces competentes del Departamento del Atlántico, sin perjuicio de los mecanismos alternativos de solución de conflictos.

12. Contacto

Para preguntas sobre estos términos, puede escribirnos a soporte@axentiatechnologies.com o por WhatsApp al +57 324 686 8538.