Servicios Softland Casos Blog Sobre nosotros Contacto

-- sincronización de stock por bodega
CREATE PROCEDURE sp_sync_stock
  @desde datetime
AS
BEGIN
  SET NOCOUNT ON;

  SELECT a.cod_prod,
         b.cod_bodega,
         SUM(b.stock_fisico) AS stock,
         GETDATE() AS sincronizado
  FROM   mae_producto a
  JOIN   mov_bodega  b ON b.cod_prod = a.cod_prod
  WHERE  a.activo = 'S'
    AND  b.fecha_mov >= @desde
  GROUP BY a.cod_prod, b.cod_bodega
  HAVING   SUM(b.stock_fisico) > 0;

  -- bitácora con reintento
  INSERT INTO backoffice_sync_log
        (entidad, referencia, estado, intento, ts)
  VALUES ('stock', @desde, 'OK', 1, GETDATE());
END
GO

-- índice para no bloquear en horario laboral
CREATE NONCLUSTERED INDEX ix_mov_bodega_fecha
  ON mov_bodega (fecha_mov) INCLUDE (cod_prod, stock_fisico);


-- sincronización de stock por bodega
CREATE PROCEDURE sp_sync_stock
  @desde datetime
AS
BEGIN
  SET NOCOUNT ON;

  SELECT a.cod_prod,
         b.cod_bodega,
         SUM(b.stock_fisico) AS stock,
         GETDATE() AS sincronizado
  FROM   mae_producto a
  JOIN   mov_bodega  b ON b.cod_prod = a.cod_prod
  WHERE  a.activo = 'S'
    AND  b.fecha_mov >= @desde
  GROUP BY a.cod_prod, b.cod_bodega
  HAVING   SUM(b.stock_fisico) > 0;

  -- bitácora con reintento
  INSERT INTO backoffice_sync_log
        (entidad, referencia, estado, intento, ts)
  VALUES ('stock', @desde, 'OK', 1, GETDATE());
END
GO

-- índice para no bloquear en horario laboral
CREATE NONCLUSTERED INDEX ix_mov_bodega_fecha
  ON mov_bodega (fecha_mov) INCLUDE (cod_prod, stock_fisico);

// worker de sincronización Softland → web
import { sql } from './mssql';
import { db }  from './postgres';

type SyncResult = {
  entidad: string;
  registros: number;
  ms: number;
};

export async function syncStock(): Promise<SyncResult> {
  const t0 = performance.now();
  const filas = await sql.query('EXEC sp_sync_stock @desde', {
    desde: lastRun('stock'),
  });

  await db.transaction(async (trx) => {
    for (const f of filas) {
      await trx('productos')
        .insert({ sku: f.cod_prod, stock: f.stock })
        .onConflict('sku')
        .merge();
    }
  });

  return {
    entidad: 'stock',
    registros: filas.length,
    ms: Math.round(performance.now() - t0),
  };
}


// worker de sincronización Softland → web
import { sql } from './mssql';
import { db }  from './postgres';

type SyncResult = {
  entidad: string;
  registros: number;
  ms: number;
};

export async function syncStock(): Promise<SyncResult> {
  const t0 = performance.now();
  const filas = await sql.query('EXEC sp_sync_stock @desde', {
    desde: lastRun('stock'),
  });

  await db.transaction(async (trx) => {
    for (const f of filas) {
      await trx('productos')
        .insert({ sku: f.cod_prod, stock: f.stock })
        .onConflict('sku')
        .merge();
    }
  });

  return {
    entidad: 'stock',
    registros: filas.length,
    ms: Math.round(performance.now() - t0),
  };
}

// conciliación de cartolas bancarias
export async function conciliar(cartola: Movimiento[]) {
  const pendientes = await cuentasPorCobrar();

  for (const mov of cartola) {
    const calce = pendientes.find((c) =>
      c.monto === mov.abono && c.rut === mov.rut);

    if (calce) {
      await aplicarPago(calce.documento, mov.fecha);
    } else {
      await dejarPendiente(mov, 'sin calce automático');
    }
  }
}

-- movimientos sin conciliar
SELECT fecha, glosa, abono, rut_cliente
FROM   banco_movimiento
WHERE  conciliado = 'N'
ORDER BY fecha DESC;


// conciliación de cartolas bancarias
export async function conciliar(cartola: Movimiento[]) {
  const pendientes = await cuentasPorCobrar();

  for (const mov of cartola) {
    const calce = pendientes.find((c) =>
      c.monto === mov.abono && c.rut === mov.rut);

    if (calce) {
      await aplicarPago(calce.documento, mov.fecha);
    } else {
      await dejarPendiente(mov, 'sin calce automático');
    }
  }
}

-- movimientos sin conciliar
SELECT fecha, glosa, abono, rut_cliente
FROM   banco_movimiento
WHERE  conciliado = 'N'
ORDER BY fecha DESC;

Inicio/Servicios/Ecommerce B2B y B2C

Ecommerce B2B y B2C

Ecommerce conectado a Softland, sin digitar pedidos

Un canal de venta en línea que muestra tu stock verdadero, respeta las condiciones comerciales de cada cliente y deja el pedido dentro del ERP.

Ver la demo de ecommerce

El problema

Qué está pasando hoy

Tus clientes te piden precios por WhatsApp, tú revisas stock a mano y después alguien digita el pedido en Softland. Dos veces el trabajo y el doble de errores.

Alcance

Qué incluye el servicio

Catálogo con stock y precios desde Softland
Listas de precio y descuentos por cliente
Portal con inicio de sesión para clientes B2B
Carro, checkout y confirmación de pedido
Ingreso automático del pedido al ERP
Historial de compras y reposición en un clic

Cómo trabajamos

Cuatro fases, precio cerrado

FASE 01

Levantamiento

Revisamos tu instalación y los procesos actuales.

FASE 02

Especificación

Alcance, entregables, plazos y precio cerrado por escrito.

FASE 03

Construcción

Entregas parciales cada dos semanas en ambiente de prueba.

FASE 04

Puesta en marcha

Migración, capacitación y monitoreo el primer mes.

Preguntas frecuentes

Lo que suelen preguntarnos

¿Sirve para vender a empresas y a público general?

Sí. El mismo sitio puede operar en modo B2B con precios por cliente y en modo B2C con precio de lista.

¿Usan WooCommerce o Shopify?

No. Se desarrolla a medida sobre Next.js y PostgreSQL, porque los plugins genéricos no resuelven bien listas de precio ni stock por bodega.

¿El stock que ve el cliente es real?

Sí, viene de Softland con la última sincronización. Se puede mostrar el minuto exacto de actualización.

¿Se integra con medios de pago chilenos?

Sí, con Webpay, Khipu o transferencia con conciliación automática.

Otros servicios

-- sincronización de stock por bodega
CREATE PROCEDURE sp_sync_stock
  @desde datetime
AS
BEGIN
  SET NOCOUNT ON;

  SELECT a.cod_prod,
         b.cod_bodega,
         SUM(b.stock_fisico) AS stock,
         GETDATE() AS sincronizado
  FROM   mae_producto a
  JOIN   mov_bodega  b ON b.cod_prod = a.cod_prod
  WHERE  a.activo = 'S'
    AND  b.fecha_mov >= @desde
  GROUP BY a.cod_prod, b.cod_bodega
  HAVING   SUM(b.stock_fisico) > 0;

  -- bitácora con reintento
  INSERT INTO backoffice_sync_log
        (entidad, referencia, estado, intento, ts)
  VALUES ('stock', @desde, 'OK', 1, GETDATE());
END
GO

-- índice para no bloquear en horario laboral
CREATE NONCLUSTERED INDEX ix_mov_bodega_fecha
  ON mov_bodega (fecha_mov) INCLUDE (cod_prod, stock_fisico);


-- sincronización de stock por bodega
CREATE PROCEDURE sp_sync_stock
  @desde datetime
AS
BEGIN
  SET NOCOUNT ON;

  SELECT a.cod_prod,
         b.cod_bodega,
         SUM(b.stock_fisico) AS stock,
         GETDATE() AS sincronizado
  FROM   mae_producto a
  JOIN   mov_bodega  b ON b.cod_prod = a.cod_prod
  WHERE  a.activo = 'S'
    AND  b.fecha_mov >= @desde
  GROUP BY a.cod_prod, b.cod_bodega
  HAVING   SUM(b.stock_fisico) > 0;

  -- bitácora con reintento
  INSERT INTO backoffice_sync_log
        (entidad, referencia, estado, intento, ts)
  VALUES ('stock', @desde, 'OK', 1, GETDATE());
END
GO

-- índice para no bloquear en horario laboral
CREATE NONCLUSTERED INDEX ix_mov_bodega_fecha
  ON mov_bodega (fecha_mov) INCLUDE (cod_prod, stock_fisico);

// worker de sincronización Softland → web
import { sql } from './mssql';
import { db }  from './postgres';

type SyncResult = {
  entidad: string;
  registros: number;
  ms: number;
};

export async function syncStock(): Promise<SyncResult> {
  const t0 = performance.now();
  const filas = await sql.query('EXEC sp_sync_stock @desde', {
    desde: lastRun('stock'),
  });

  await db.transaction(async (trx) => {
    for (const f of filas) {
      await trx('productos')
        .insert({ sku: f.cod_prod, stock: f.stock })
        .onConflict('sku')
        .merge();
    }
  });

  return {
    entidad: 'stock',
    registros: filas.length,
    ms: Math.round(performance.now() - t0),
  };
}


// worker de sincronización Softland → web
import { sql } from './mssql';
import { db }  from './postgres';

type SyncResult = {
  entidad: string;
  registros: number;
  ms: number;
};

export async function syncStock(): Promise<SyncResult> {
  const t0 = performance.now();
  const filas = await sql.query('EXEC sp_sync_stock @desde', {
    desde: lastRun('stock'),
  });

  await db.transaction(async (trx) => {
    for (const f of filas) {
      await trx('productos')
        .insert({ sku: f.cod_prod, stock: f.stock })
        .onConflict('sku')
        .merge();
    }
  });

  return {
    entidad: 'stock',
    registros: filas.length,
    ms: Math.round(performance.now() - t0),
  };
}

// conciliación de cartolas bancarias
export async function conciliar(cartola: Movimiento[]) {
  const pendientes = await cuentasPorCobrar();

  for (const mov of cartola) {
    const calce = pendientes.find((c) =>
      c.monto === mov.abono && c.rut === mov.rut);

    if (calce) {
      await aplicarPago(calce.documento, mov.fecha);
    } else {
      await dejarPendiente(mov, 'sin calce automático');
    }
  }
}

-- movimientos sin conciliar
SELECT fecha, glosa, abono, rut_cliente
FROM   banco_movimiento
WHERE  conciliado = 'N'
ORDER BY fecha DESC;


// conciliación de cartolas bancarias
export async function conciliar(cartola: Movimiento[]) {
  const pendientes = await cuentasPorCobrar();

  for (const mov of cartola) {
    const calce = pendientes.find((c) =>
      c.monto === mov.abono && c.rut === mov.rut);

    if (calce) {
      await aplicarPago(calce.documento, mov.fecha);
    } else {
      await dejarPendiente(mov, 'sin calce automático');
    }
  }
}

-- movimientos sin conciliar
SELECT fecha, glosa, abono, rut_cliente
FROM   banco_movimiento
WHERE  conciliado = 'N'
ORDER BY fecha DESC;

Primer paso

Cuéntanos qué proceso te está costando caro

Una reunión de 30 minutos. Revisamos tu requerimiento y te decimos si tiene solución, cuánto demora y cuánto cuesta. Si no podemos ayudarte, también te lo decimos.

Escribir por WhatsApp