2013 lines
77 KiB
Plaintext
2013 lines
77 KiB
Plaintext
{
|
|
-------------------------------------------------------------------------------
|
|
PROGRAMA : IPPRCS004
|
|
OBJETIVO : Consulta Maestra de Productos con existencia
|
|
PROGRAMADOR : Ing. Juan F. Soto
|
|
FECHA REALIZACION : Julio 18, 1996.
|
|
MODIFICADO POR : Ing. Elvis Garcia
|
|
FECHA MODIFICACION : Junio 3, 2024.
|
|
-------------------------------------------------------------------------------
|
|
}
|
|
IMPORT os
|
|
GLOBALS "ipprgb000.4gl"
|
|
|
|
DEFINE bodega1, cod_n, cod_grupo, cod_tipo, cod_sec INT
|
|
|
|
DEFINE
|
|
productos DYNAMIC ARRAY OF RECORD
|
|
producto, parent, bodega, ubicacion VARCHAR(255),
|
|
existencia DEC(12, 5)
|
|
END RECORD,
|
|
pperfil SMALLINT,
|
|
accesso VARCHAR(2),
|
|
exitFlag BOOLEAN
|
|
|
|
DEFINE prod1 DYNAMIC ARRAY OF RECORD
|
|
estado STRING,
|
|
cod_n SMALLINT,
|
|
cod_grupo SMALLINT,
|
|
cod_tipo SMALLINT,
|
|
cod_sec SMALLINT,
|
|
descrip_esp CHAR(180),
|
|
unidad_med LIKE iptb00002.unidad_med,
|
|
bodega CHAR(50),
|
|
existencia DECIMAL(12, 5),
|
|
cantidad_ordenes DEC(12, 5),
|
|
disponible DEC(12, 5),
|
|
reservado DEC(12, 5),
|
|
transito DEC(12, 5),
|
|
valorOrden DEC(12, 5),
|
|
parent_id, child_id STRING
|
|
END RECORD
|
|
|
|
DEFINE
|
|
ubicaciones INT,
|
|
load_ubicaciones DYNAMIC ARRAY OF INTEGER,
|
|
bodegas DYNAMIC ARRAY OF INTEGER,
|
|
## Codigo de bodega indexado por FILA VISIBLE del arbol (arr_curr()),
|
|
## a diferencia de bodegas[] que va por ordinal de producto (z).
|
|
bodega_fila DYNAMIC ARRAY OF INTEGER
|
|
|
|
DEFINE prepHijos, prepTree, prepAjuste BOOLEAN
|
|
|
|
MAIN
|
|
DEFER INTERRUPT
|
|
CALL ARG_VAL(1) RETURNING usuarios
|
|
CALL ARG_VAL(2) RETURNING clave
|
|
CALL ARG_VAL(3) RETURNING impresor
|
|
CONNECT TO "smarmotech" USER usuarios USING clave
|
|
|
|
SELECT a.cod_perfil INTO pperfil FROM seg0001 a WHERE a.usuario = usuarios
|
|
|
|
CALL ipprcs004()
|
|
END MAIN
|
|
|
|
FUNCTION ipprcs004()
|
|
DEFINE
|
|
pcantidadConduce, pexistencia DEC(12, 5),
|
|
codigo_act, codigo_ant VARCHAR(50)
|
|
|
|
DEFINE i, j, bodegaCont, z INT
|
|
DEFINE answer STRING
|
|
LET exitFlag = FALSE
|
|
|
|
INITIALIZE bodega1, cod_n, cod_grupo, cod_tipo, cod_sec TO NULL
|
|
|
|
OPEN FORM ipfmcs004 FROM "ipfmcs004"
|
|
DISPLAY FORM ipfmcs004
|
|
CALL ui.Interface.LoadStyles("mbsStyle")
|
|
|
|
## Aqui se prepara el criterio de seleccion
|
|
DIALOG ATTRIBUTES(FIELD ORDER FORM, UNBUFFERED)
|
|
INPUT BY NAME datos_cons.fech_fi, inventario
|
|
BEFORE INPUT
|
|
LET datos_cons.fech_fi = TODAY
|
|
|
|
CALL prod1.clear()
|
|
|
|
DISPLAY BY NAME datos_cons.fech_fi
|
|
IF datos_cons.fech_fi IS NULL THEN
|
|
LET numero_msg = 16
|
|
CALL msg(numero_msg)
|
|
NEXT FIELD fech_fi
|
|
END IF
|
|
AFTER INPUT
|
|
|
|
END INPUT
|
|
|
|
CONSTRUCT criterio
|
|
ON b.bodega,
|
|
a.cod_n,
|
|
a.cod_grupo,
|
|
a.cod_tipo,
|
|
a.cod_sec,
|
|
a.descrip_esp
|
|
FROM bodega, cod_n, cod_grupo, cod_tipo, cod_sec, descrip_esp
|
|
BEFORE CONSTRUCT
|
|
CALL prod1.clear()
|
|
CALL bodegas("1")
|
|
ON ACTION Buscar ATTRIBUTES(IMAGE = "find")
|
|
IF inventario = "PRODUCTOS TERMINADOS" THEN
|
|
LET SELEC =
|
|
"SELECT ' ',a.cod_n,a.cod_grupo,a.cod_tipo,a.cod_sec,a.descrip_esp,",
|
|
" a.unidad_med,c.descripcion,SUM(b.cantidad_2), ",
|
|
" '0','0','0','0',c.cod_bodega ",
|
|
"FROM iptb00002 a,iptb00006 b,intb00009 c ",
|
|
"WHERE ",
|
|
" (a.cod_n = b.cod_n and a.cod_grupo = b.cod_grupo and a.cod_tipo = b.cod_tipo and ",
|
|
" a.cod_sec = b.cod_Sec) and b.bodega = c.cod_bodega AND b.status_t is null and ",
|
|
" b.fecha < '",
|
|
(datos_cons.fech_fi + 1) USING "yyyy-mm-dd",
|
|
"' and ",
|
|
" a.status_t is null AND ",
|
|
criterio CLIPPED,
|
|
" GROUP BY c.cod_bodega,a.cod_n,a.cod_grupo,a.cod_tipo,a.cod_sec,a.descrip_esp,a.unidad_med,c.descripcion ",
|
|
" ORDER BY c.cod_bodega,a.cod_n,a.cod_grupo,a.cod_tipo,a.cod_sec "
|
|
|
|
END IF
|
|
|
|
IF inventario = "MATERIA PRIMA" THEN
|
|
LET SELEC =
|
|
"SELECT ' ',a.cod_n,a.cod_grupo,a.cod_tipo,a.cod_sec,a.descrip_esp,",
|
|
" a.unidad_med,c.descripcion,SUM(b.cantidad_2) ",
|
|
"FROM intb00001 a,intb00006 b,intb00009 c ",
|
|
"WHERE ",
|
|
" a.cod_n = b.cod_n and a.cod_grupo = b.cod_grupo and a.cod_tipo = b.cod_tipo and ",
|
|
" a.cod_sec = b.cod_Sec and b.bodega = c.cod_bodega and ",
|
|
" b.fecha < '",
|
|
(datos_cons.fech_fi + 1) USING "yyyy-mm-dd",
|
|
"' ",
|
|
" AND a.status_t is null AND b.status_t is null and ",
|
|
criterio CLIPPED,
|
|
" GROUP BY a.cod_n,a.cod_grupo,a.cod_tipo,a.cod_sec,a.descrip_esp,a.unidad_med,c.descripcion ",
|
|
" ORDER BY cod_n,a.cod_grupo,a.cod_tipo,a.cod_sec "
|
|
END IF
|
|
PREPARE busca FROM selec
|
|
DECLARE accion CURSOR FOR busca
|
|
|
|
## Busca los registros con la condicion dada y verifica si el producto terminado
|
|
## existe en el catalogo de bienes y servicios.
|
|
|
|
LET idx = 1
|
|
LET j = 0
|
|
LET z = 1
|
|
CALL prod1.clear()
|
|
CALL bodegas.clear()
|
|
CALL bodega_fila.clear()
|
|
CALL load_ubicaciones.clear()
|
|
LET codigo_ant = '0'
|
|
LET codigo_act = '0'
|
|
FOREACH accion INTO prod1[idx].*
|
|
LET ubicaciones = 0
|
|
LET codigo_act =
|
|
prod1[idx].cod_n USING "&&&&&",
|
|
prod1[idx].cod_grupo USING "&&&&&",
|
|
prod1[idx].cod_tipo USING "&&&&&",
|
|
prod1[idx].cod_sec USING "&&&&&&&&"
|
|
|
|
LET prod1[idx].estado = NULL
|
|
SELECT UNIQUE a.cod_sec
|
|
FROM iptb00050 a
|
|
WHERE a.cod_n = prod1[idx].cod_n
|
|
AND a.cod_grupo = prod1[idx].cod_grupo
|
|
AND a.cod_tipo = prod1[idx].cod_tipo
|
|
AND a.cod_sec = prod1[idx].cod_sec
|
|
|
|
IF STATUS <> NOTFOUND THEN
|
|
LET prod1[idx].estado = "information.png"
|
|
END IF
|
|
IF prod1[idx].existencia IS NULL THEN
|
|
LET prod1[idx].existencia = 0
|
|
END IF
|
|
|
|
LET prod1[idx].cantidad_ordenes = 0
|
|
|
|
IF codigo_ant <> codigo_act THEN
|
|
LET codigo_ant =
|
|
prod1[idx].cod_n USING "&&&&",
|
|
prod1[idx].cod_grupo USING "&&&&",
|
|
prod1[idx].cod_tipo USING "&&&&",
|
|
prod1[idx].cod_sec USING "&&&&&&"
|
|
|
|
CALL disponibles(
|
|
prod1[idx].cod_n,
|
|
prod1[idx].cod_grupo,
|
|
prod1[idx].cod_tipo,
|
|
prod1[idx].cod_sec,
|
|
datos_cons.fech_fi)
|
|
RETURNING prod1[idx].cantidad_ordenes,
|
|
pcantidadConduce,
|
|
prod1[idx].transito,
|
|
pexistencia,
|
|
prod1[idx].reservado,
|
|
prod1[idx].valorOrden
|
|
|
|
LET prod1[idx].cantidad_ordenes =
|
|
prod1[idx].cantidad_ordenes - pcantidadConduce
|
|
|
|
IF prod1[idx].cantidad_ordenes = 0 THEN
|
|
LET prod1[idx].valorOrden = 0
|
|
END IF
|
|
END IF
|
|
IF prod1[idx].existencia IS NULL THEN
|
|
LET prod1[idx].existencia = 0
|
|
END IF
|
|
IF prod1[idx].cantidad_ordenes IS NULL THEN
|
|
LET prod11[idx].cantidad_ordenes = 0
|
|
END IF
|
|
IF prod1[idx].disponible IS NULL THEN
|
|
LET prod1[idx].disponible = 0
|
|
END IF
|
|
LET prod1[idx].disponible =
|
|
pexistencia
|
|
- prod1[idx].cantidad_ordenes
|
|
- prod1[idx].reservado
|
|
LET productos[idx].producto =
|
|
prod1[idx].cod_n USING "&&&&",
|
|
prod1[idx].cod_grupo USING "&&&&",
|
|
prod1[idx].cod_tipo USING "&&&&",
|
|
prod1[idx].cod_sec USING "&&&&&&",
|
|
" ",
|
|
prod1[idx].descrip_esp
|
|
LET productos[idx].bodega = prod1[idx].bodega
|
|
LET productos[idx].existencia = prod1[idx].existencia
|
|
LET productos[idx].parent = prod1[idx].bodega
|
|
|
|
CALL LlenarHijos(
|
|
prod1[idx].*)
|
|
RETURNING bodegaCont, ubicaciones
|
|
|
|
LET bodegas[z] = bodegacont
|
|
LET bodega_fila[idx] = bodegacont
|
|
LET load_ubicaciones[z] = ubicaciones
|
|
LET z = z + 1
|
|
|
|
LET INT_FLAG = FALSE
|
|
|
|
IF ubicaciones > 0 THEN
|
|
LET j = idx + 1
|
|
LET INT_FLAG = TRUE
|
|
|
|
LET prod1[idx].parent_id = NULL
|
|
LET prod1[idx].child_id = 1
|
|
|
|
CALL treeFunction(
|
|
j,
|
|
prod1[idx].cod_n,
|
|
prod1[idx].cod_grupo,
|
|
prod1[idx].cod_tipo,
|
|
prod1[idx].cod_sec,
|
|
bodegaCont,
|
|
prod1[idx].existencia)
|
|
RETURNING j
|
|
|
|
END IF
|
|
|
|
IF INT_FLAG THEN
|
|
LET idx = j
|
|
ELSE
|
|
LET idx = idx + 1
|
|
END IF
|
|
|
|
INITIALIZE ubicaciones TO NULL
|
|
|
|
END FOREACH
|
|
IF idx = 1 THEN
|
|
CALL msg(3)
|
|
|
|
DISPLAY criterio
|
|
|
|
LET bodega1 = extract_value(criterio, "b.bodega")
|
|
LET cod_n = extract_value(criterio, "a.cod_n")
|
|
LET cod_grupo = extract_value(criterio, "a.cod_grupo")
|
|
LET cod_tipo = extract_value(criterio, "a.cod_tipo")
|
|
LET cod_sec = extract_value(criterio, "a.cod_sec")
|
|
|
|
DISPLAY 'bodega: ', bodega1
|
|
DISPLAY 'cod_n: ', cod_n
|
|
DISPLAY 'cod_grupo: ', cod_grupo
|
|
DISPLAY 'cod_tipo: ', cod_tipo
|
|
DISPLAY 'cod_sec: ', cod_sec
|
|
|
|
IF bodega1 IS NOT NULL
|
|
AND cod_n IS NOT NULL
|
|
AND cod_grupo IS NOT NULL
|
|
AND cod_tipo IS NOT NULL
|
|
AND cod_sec IS NOT NULL THEN
|
|
|
|
SELECT UNIQUE a.cod_grupo
|
|
FROM iptb00006 a
|
|
WHERE a.cod_n = cod_n
|
|
AND a.cod_grupo = cod_grupo
|
|
AND a.cod_tipo = cod_tipo
|
|
AND a.cod_sec = cod_sec
|
|
AND a.status_t IS NULL
|
|
|
|
IF STATUS <> NOTFOUND THEN
|
|
|
|
LET answer =
|
|
fgl_winquestion(
|
|
'PRODUCTO NO DISPONIBLE EN SU BODEGA',
|
|
"Este producto no se encuentra en su bodega, desea adicionarlo sin existencia?",
|
|
"yes",
|
|
"yes|no",
|
|
"question",
|
|
0)
|
|
|
|
IF answer = 'yes' THEN
|
|
|
|
TRY
|
|
|
|
BEGIN WORK
|
|
|
|
INSERT INTO iptb00006(
|
|
cod_cia,
|
|
num_doc,
|
|
fecha,
|
|
cod_mov,
|
|
detalle,
|
|
area,
|
|
cod_n,
|
|
cod_grupo,
|
|
cod_tipo,
|
|
cod_sec,
|
|
cantidad_1,
|
|
cantidad_2,
|
|
bodega,
|
|
status_t,
|
|
us_crea,
|
|
fech_crea,
|
|
us_mod,
|
|
fech_mod)
|
|
VALUES(1,
|
|
99,
|
|
getdate(),
|
|
99,
|
|
NULL,
|
|
NULL,
|
|
cod_n,
|
|
cod_grupo,
|
|
cod_tipo,
|
|
cod_sec,
|
|
0,
|
|
0,
|
|
bodega1,
|
|
NULL,
|
|
usuarios,
|
|
getdate(),
|
|
NULL,
|
|
NULL)
|
|
|
|
INSERT INTO iptb00062(
|
|
num_doc,
|
|
fecha,
|
|
area,
|
|
cod_n,
|
|
cod_grupo,
|
|
cod_tipo,
|
|
cod_sec,
|
|
cod_mov,
|
|
bodega,
|
|
cod_seccion,
|
|
cod_tramo,
|
|
cod_fila,
|
|
cod_pos,
|
|
cantidad,
|
|
cantidad2,
|
|
status_t,
|
|
us_crea,
|
|
fech_crea,
|
|
us_mod,
|
|
fech_mod)
|
|
VALUES(99,
|
|
getdate(),
|
|
NULL,
|
|
cod_n,
|
|
cod_grupo,
|
|
cod_tipo,
|
|
cod_sec,
|
|
99,
|
|
bodega1,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
NULL,
|
|
usuarios,
|
|
getdate(),
|
|
NULL,
|
|
NULL)
|
|
|
|
COMMIT WORK
|
|
LET numero_msg = 1
|
|
CALL msg(numero_msg)
|
|
CONTINUE DIALOG
|
|
|
|
CATCH
|
|
ROLLBACK WORK
|
|
LET numero_msg = 1663
|
|
CALL msg(numero_msg)
|
|
|
|
END TRY
|
|
|
|
ELSE
|
|
CONTINUE DIALOG
|
|
END IF
|
|
|
|
END IF
|
|
END IF
|
|
CONTINUE DIALOG
|
|
END IF
|
|
|
|
DISPLAY ARRAY prod1 TO consart.*
|
|
ON ACTION ordenDisponible
|
|
IF prod1[arr_curr()].cantidad_ordenes <> 0 THEN
|
|
CALL busca_ordenes_reservadas(
|
|
prod1[arr_curr()].cod_n,
|
|
prod1[arr_curr()].cod_grupo,
|
|
prod1[arr_curr()].cod_tipo,
|
|
prod1[arr_curr()].cod_sec)
|
|
ELSE
|
|
CALL fgl_winmessage(
|
|
"INFO",
|
|
"PRODUCTO NO TIENE ORDENES COLOCADAS",
|
|
"INFO")
|
|
END IF
|
|
|
|
ON ACTION reservado
|
|
LET idx = arr_curr()
|
|
IF prod1[idx].reservado > 0 THEN
|
|
CALL busca_reservas(
|
|
prod1[idx].cod_n,
|
|
prod1[idx].cod_grupo,
|
|
prod1[idx].cod_tipo,
|
|
prod1[idx].cod_sec)
|
|
ELSE
|
|
CALL fgl_winmessage(
|
|
"ERROR",
|
|
"PRODUCTO NO TIENE CANTIDAD RESERVADA",
|
|
"INFO")
|
|
END IF
|
|
|
|
{ ON ACTION foto
|
|
LET idx = arr_curr()
|
|
CALL fotos(prod1[idx].cod_n,prod1[idx].cod_grupo,prod1[idx].cod_tipo,
|
|
prod1[idx].cod_sec,prod1[idx].descrip_esp,usuarios,true)
|
|
LET prod1[idx].estado = " "
|
|
SELECT UNIQUE a.cod_sec FROM iptb00050 a
|
|
WHERE a.cod_n = prod1[idx].cod_n AND
|
|
a.cod_grupo = prod1[idx].cod_grupo AND
|
|
a.cod_tipo = prod1[idx].cod_tipo AND
|
|
a.cod_sec = prod1[idx].cod_sec
|
|
|
|
IF STATUS <> NOTFOUND THEN
|
|
LET prod1[idx].estado = "information.png"
|
|
END IF
|
|
DISPLAY prod1[idx].estado TO consart[scr_line()].estado}
|
|
ON ACTION imprime
|
|
ATTRIBUTE(TEXT = "Reporte", IMAGE = 'print')
|
|
CALL seg000(
|
|
usuarios, pperfil, 'reporte.ipprcs004')
|
|
RETURNING accesso
|
|
DISPLAY "usuario ", usuarios, " ", pperfil
|
|
IF accesso = "SI" THEN
|
|
|
|
CALL reporteData()
|
|
ELSE
|
|
CALL msg(503)
|
|
END IF
|
|
|
|
ON ACTION ubicar
|
|
|
|
SELECT a.usuario
|
|
FROM seg0001 a, seg0005 b
|
|
WHERE a.usuario = usuarios
|
|
AND a.cod_perfil = b.cod_perfil
|
|
AND b.programa = 'ipprcs004.ubicacion'
|
|
|
|
IF STATUS = NOTFOUND THEN
|
|
CALL fgl_winmessage(
|
|
"ERROR",
|
|
"USTED NO TIENE PERMISOS PARA UTILIZAR OPCION",
|
|
"INFO")
|
|
CONTINUE DIALOG
|
|
|
|
ELSE
|
|
|
|
SELECT UNIQUE a.usuario
|
|
FROM iptb00048 a
|
|
WHERE a.bodega = bodegas[arr_curr()]
|
|
AND a.usuario = usuarios
|
|
|
|
IF STATUS = NOTFOUND THEN
|
|
CALL msg(503)
|
|
ELSE
|
|
|
|
IF load_ubicaciones[arr_curr()] > 0 THEN
|
|
CALL InsertaUbicacionDH(
|
|
prod1[arr_curr()].*, NULL)
|
|
RETURNING exitFlag
|
|
ELSE
|
|
CALL colocar_ubicacion(prod1[arr_curr()].*)
|
|
|
|
IF prod1[arr_curr()].estado IS NOT NULL
|
|
AND prod1[arr_curr()]
|
|
.bodega IS NULL THEN
|
|
|
|
LET INT_FLAG = TRUE
|
|
LET i = 1
|
|
|
|
WHILE INT_FLAG
|
|
|
|
IF prod1[arr_curr() - i]
|
|
.cod_n IS NOT NULL THEN
|
|
|
|
CALL InsertaUbicacionDH(
|
|
prod1[arr_curr() - i].*,
|
|
prod1[arr_curr()].estado)
|
|
RETURNING exitFlag
|
|
|
|
LET INT_FLAG = FALSE
|
|
|
|
ELSE
|
|
|
|
LET i = i + 1
|
|
|
|
END IF
|
|
|
|
END WHILE
|
|
|
|
END IF
|
|
|
|
END IF
|
|
|
|
IF exitFlag THEN
|
|
|
|
LET idx = 1
|
|
LET j = 0
|
|
LET z = 1
|
|
CALL prod1.clear()
|
|
CALL bodegas.clear()
|
|
CALL bodega_fila.clear()
|
|
CALL load_ubicaciones.clear()
|
|
LET codigo_ant = '0'
|
|
LET codigo_act = '0'
|
|
|
|
FOREACH accion INTO prod1[idx].*,bodegas[idx]
|
|
LET ubicaciones = 0
|
|
LET codigo_act =
|
|
prod1[idx].cod_n USING "&&&&&",
|
|
prod1[idx].cod_grupo USING "&&&&&",
|
|
prod1[idx].cod_tipo USING "&&&&&",
|
|
prod1[idx].cod_sec USING "&&&&&&&&"
|
|
|
|
LET prod1[idx].estado = NULL
|
|
SELECT UNIQUE a.cod_sec
|
|
FROM iptb00050 a
|
|
WHERE a.cod_n = prod1[idx].cod_n
|
|
AND a.cod_grupo
|
|
=
|
|
prod1[idx].cod_grupo
|
|
AND a.cod_tipo
|
|
=
|
|
prod1[idx].cod_tipo
|
|
AND a.cod_sec
|
|
=
|
|
prod1[idx].cod_sec
|
|
|
|
IF STATUS <> NOTFOUND THEN
|
|
LET prod1[idx].estado =
|
|
"information.png"
|
|
END IF
|
|
IF prod1[idx].existencia IS NULL THEN
|
|
LET prod1[idx].existencia = 0
|
|
END IF
|
|
|
|
LET prod1[idx].cantidad_ordenes = 0
|
|
|
|
IF codigo_ant <> codigo_act THEN
|
|
LET codigo_ant =
|
|
prod1[idx].cod_n USING "&&&&",
|
|
prod1[idx].cod_grupo
|
|
USING "&&&&",
|
|
prod1[idx].cod_tipo
|
|
USING "&&&&",
|
|
prod1[idx].cod_sec
|
|
USING "&&&&&&"
|
|
|
|
CALL disponibles(
|
|
prod1[idx].cod_n,
|
|
prod1[idx].cod_grupo,
|
|
prod1[idx].cod_tipo,
|
|
prod1[idx].cod_sec,
|
|
datos_cons.fech_fi)
|
|
RETURNING prod1[idx]
|
|
.cantidad_ordenes,
|
|
pcantidadConduce,
|
|
prod1[idx].transito,
|
|
pexistencia,
|
|
prod1[idx].reservado,
|
|
prod1[idx].valorOrden
|
|
|
|
LET prod1[idx].cantidad_ordenes =
|
|
prod1[idx].cantidad_ordenes
|
|
- pcantidadConduce
|
|
|
|
IF prod1[idx].cantidad_ordenes
|
|
= 0 THEN
|
|
LET prod1[idx].valorOrden = 0
|
|
END IF
|
|
END IF
|
|
IF prod1[idx].existencia IS NULL THEN
|
|
LET prod1[idx].existencia = 0
|
|
END IF
|
|
IF prod1[idx]
|
|
.cantidad_ordenes IS NULL THEN
|
|
LET prod11[idx].cantidad_ordenes = 0
|
|
END IF
|
|
IF prod1[idx].disponible IS NULL THEN
|
|
LET prod1[idx].disponible = 0
|
|
END IF
|
|
|
|
LET prod1[idx].disponible =
|
|
pexistencia
|
|
- prod1[idx].cantidad_ordenes
|
|
- prod1[idx].reservado
|
|
LET productos[idx].producto =
|
|
prod1[idx].cod_n USING "&&&&",
|
|
prod1[idx].cod_grupo USING "&&&&",
|
|
prod1[idx].cod_tipo USING "&&&&",
|
|
prod1[idx].cod_sec USING "&&&&&&",
|
|
" ",
|
|
prod1[idx].descrip_esp
|
|
LET productos[idx].bodega =
|
|
prod1[idx].bodega
|
|
LET productos[idx].existencia =
|
|
prod1[idx].existencia
|
|
LET productos[idx].parent =
|
|
prod1[idx].bodega
|
|
|
|
CALL LlenarHijos(
|
|
prod1[idx].*)
|
|
RETURNING bodegaCont, ubicaciones
|
|
|
|
LET bodegas[z] = bodegacont
|
|
LET bodega_fila[idx] = bodegacont
|
|
LET load_ubicaciones[z] = ubicaciones
|
|
LET z = z + 1
|
|
|
|
LET INT_FLAG = FALSE
|
|
|
|
IF ubicaciones > 0 THEN
|
|
LET j = idx + 1
|
|
LET INT_FLAG = TRUE
|
|
|
|
LET prod1[idx].parent_id = NULL
|
|
LET prod1[idx].child_id = 1
|
|
|
|
CALL treeFunction(
|
|
j,
|
|
prod1[idx].cod_n,
|
|
prod1[idx].cod_grupo,
|
|
prod1[idx].cod_tipo,
|
|
prod1[idx].cod_sec,
|
|
bodegaCont,
|
|
prod1[idx].existencia)
|
|
RETURNING j
|
|
|
|
END IF
|
|
|
|
IF INT_FLAG THEN
|
|
LET idx = j
|
|
ELSE
|
|
LET idx = idx + 1
|
|
END IF
|
|
|
|
INITIALIZE ubicaciones TO NULL
|
|
|
|
END FOREACH
|
|
|
|
IF idx = 1 THEN
|
|
CALL msg(3)
|
|
CONTINUE DIALOG
|
|
END IF
|
|
|
|
END IF
|
|
|
|
END IF
|
|
|
|
END IF
|
|
|
|
ON ACTION ajustar
|
|
ATTRIBUTES(TEXT = "Ajustar Ubic.", IMAGE = "edit")
|
|
|
|
LET idx = arr_curr()
|
|
|
|
## El ajuste solo aplica sobre una fila de producto/bodega.
|
|
## Las filas del arbol de ubicaciones tienen cod_n NULL.
|
|
IF prod1[idx].cod_n IS NULL
|
|
OR prod1[idx].bodega IS NULL THEN
|
|
CALL fgl_winmessage(
|
|
"INFO",
|
|
"Seleccione un producto (fila de bodega) para ajustar sus ubicaciones.",
|
|
"info")
|
|
CONTINUE DISPLAY
|
|
END IF
|
|
|
|
## Mismo control de permiso que la opcion de ubicar.
|
|
SELECT a.usuario
|
|
FROM seg0001 a, seg0005 b
|
|
WHERE a.usuario = usuarios
|
|
AND a.cod_perfil = b.cod_perfil
|
|
AND b.programa = 'ipprcs004.ubicacion'
|
|
|
|
IF STATUS = NOTFOUND THEN
|
|
CALL fgl_winmessage(
|
|
"ERROR",
|
|
"USTED NO TIENE PERMISOS PARA UTILIZAR OPCION",
|
|
"INFO")
|
|
CONTINUE DISPLAY
|
|
END IF
|
|
|
|
IF ajustar_ubicaciones(
|
|
prod1[idx].cod_n,
|
|
prod1[idx].cod_grupo,
|
|
prod1[idx].cod_tipo,
|
|
prod1[idx].cod_sec,
|
|
bodega_fila[idx],
|
|
prod1[idx].bodega,
|
|
prod1[idx].descrip_esp,
|
|
prod1[idx].existencia) THEN
|
|
## Se aplico el ajuste: refrescar el arbol en pantalla.
|
|
CALL recargar_arbol()
|
|
END IF
|
|
|
|
AFTER DISPLAY
|
|
CALL prod1.clear()
|
|
END DISPLAY
|
|
END CONSTRUCT
|
|
|
|
ON ACTION CANCEL ATTRIBUTES(TEXT = "Cancelar", IMAGE = "cancel")
|
|
CALL prod1.clear()
|
|
CALL msg(2)
|
|
LET INT_FLAG = FALSE
|
|
EXIT PROGRAM
|
|
END DIALOG
|
|
END FUNCTION
|
|
|
|
FUNCTION LlenarHijos(prod1)
|
|
|
|
DEFINE
|
|
prod1 RECORD
|
|
estado VARCHAR(20),
|
|
cod_n SMALLINT,
|
|
cod_grupo SMALLINT,
|
|
cod_tipo SMALLINT,
|
|
cod_sec SMALLINT,
|
|
descrip_esp CHAR(180),
|
|
unidad_med LIKE iptb00002.unidad_med,
|
|
bodega CHAR(50),
|
|
existencia DECIMAL(12, 5),
|
|
cantidad_ordenes DEC(12, 5),
|
|
disponible DEC(12, 5),
|
|
reservado DEC(12, 5),
|
|
transito DEC(12, 5),
|
|
valorOrden DEC(16, 5),
|
|
parent_id, child_id VARCHAR(20)
|
|
END RECORD,
|
|
bodegaCont, checking INT,
|
|
Query STRING
|
|
|
|
## Los statements se preparan una sola vez por ejecucion del programa,
|
|
## no en cada fila (antes se hacia PREPARE por cada producto).
|
|
IF NOT prepHijos THEN
|
|
LET query =
|
|
"SELECT DISTINCT a.cod_bodega
|
|
FROM intb00009 a INNER JOIN iptb00006 b ON a.cod_bodega = b.bodega
|
|
WHERE cod_n = ?
|
|
AND cod_grupo = ?
|
|
AND cod_tipo = ?
|
|
AND cod_sec = ?
|
|
AND a.descripcion = ?"
|
|
PREPARE busqueda1 FROM query
|
|
|
|
LET query =
|
|
"SELECT COUNT(cod_seccion)
|
|
FROM iptb00062
|
|
WHERE cod_n = ?
|
|
AND cod_grupo = ?
|
|
AND cod_tipo = ?
|
|
AND cod_sec = ?
|
|
AND bodega = ? "
|
|
PREPARE busqueda2 FROM query
|
|
|
|
LET prepHijos = TRUE
|
|
END IF
|
|
|
|
EXECUTE busqueda1
|
|
USING prod1.cod_n,
|
|
prod1.cod_grupo,
|
|
prod1.cod_tipo,
|
|
prod1.cod_sec,
|
|
prod1.bodega
|
|
INTO bodegaCont
|
|
|
|
EXECUTE busqueda2
|
|
USING prod1.cod_n,
|
|
prod1.cod_grupo,
|
|
prod1.cod_tipo,
|
|
prod1.cod_sec,
|
|
bodegaCont
|
|
INTO checking
|
|
|
|
RETURN bodegaCont, checking
|
|
|
|
END FUNCTION
|
|
|
|
FUNCTION treeFunction(
|
|
j INT,
|
|
cod_n1 INT,
|
|
cod_grupo1 INT,
|
|
cod_tipo1 INT,
|
|
cod_sec1 INT,
|
|
bodegaCont INT,
|
|
existencia DECIMAL(12, 5))
|
|
|
|
DEFINE MirrorLocation DYNAMIC ARRAY OF RECORD
|
|
seccion STRING,
|
|
cod_seccion INT,
|
|
existenciaSec DECIMAL(12, 5),
|
|
tramo STRING,
|
|
cod_tramo INT,
|
|
existenciaTram DECIMAL(12, 5),
|
|
fila STRING,
|
|
cod_fila INT,
|
|
existenciaFil DECIMAL(12, 5),
|
|
posicion STRING,
|
|
cod_pos INT,
|
|
existenciaPos DECIMAL(12, 5)
|
|
END RECORD
|
|
|
|
DEFINE Container DYNAMIC ARRAY OF RECORD
|
|
seccion STRING,
|
|
cod_seccion INT,
|
|
existenciaSec DECIMAL(12, 5),
|
|
tramo STRING,
|
|
cod_tramo INT,
|
|
existenciaTram DECIMAL(12, 5),
|
|
fila STRING,
|
|
cod_fila INT,
|
|
existenciaFil DECIMAL(12, 5),
|
|
posicion STRING,
|
|
cod_pos INT,
|
|
existenciaPos DECIMAL(12, 5)
|
|
END RECORD
|
|
|
|
DEFINE i, z INT
|
|
CONSTANT firstID = 1
|
|
DEFINE counterSec, counterTram, counterFil, counterPos INT
|
|
DEFINE NextTree, NextTree2 BOOLEAN
|
|
DEFINE consulta STRING
|
|
|
|
LET i = 1
|
|
LET counterSec = 2
|
|
LET counterTram = 1
|
|
LET counterFil = 1
|
|
LET counterPos = 1
|
|
LET nextTree = FALSE
|
|
LET nextTree2 = FALSE
|
|
|
|
INITIALIZE MirrorLocation TO NULL
|
|
|
|
LET consulta =
|
|
"SELECT
|
|
RTRIM(a.descripcion) AS seccion,
|
|
a.cod_seccion as cod_seccion,
|
|
(SELECT SUM(cantidad2)
|
|
FROM iptb00062
|
|
WHERE (bodega = t.bodega AND cod_seccion = t.cod_seccion and cod_n = t.cod_n and cod_grupo = t.cod_grupo and cod_tipo = t.cod_tipo and cod_sec = t.cod_sec) and status_t is null) AS suma_cantidad2_seccion,
|
|
RTRIM(b.descripcion) AS tramo,
|
|
b.cod_tramo as cod_tramo,
|
|
(SELECT SUM(cantidad2)
|
|
FROM iptb00062
|
|
WHERE (bodega = t.bodega AND cod_seccion = t.cod_seccion AND cod_tramo = t.cod_tramo and cod_n = t.cod_n and cod_grupo = t.cod_grupo and cod_tipo = t.cod_tipo and cod_sec = t.cod_sec) and status_t is null) AS suma_cantidad2_tramo,
|
|
RTRIM(c.titulo) AS fila,
|
|
c.cod_fila as cod_fila,
|
|
(SELECT SUM(cantidad2)
|
|
FROM iptb00062
|
|
WHERE (bodega = t.bodega AND cod_seccion = t.cod_seccion AND cod_tramo = t.cod_tramo AND cod_fila = t.cod_fila and cod_n = t.cod_n and cod_grupo = t.cod_grupo and cod_tipo = t.cod_tipo and cod_sec = t.cod_sec) and status_t is null) AS suma_cantidad2_fila,
|
|
RTRIM(d.titulo) AS posicion,
|
|
d.cod_pos as cod_pos,
|
|
(SELECT SUM(cantidad2)
|
|
FROM iptb00062
|
|
WHERE (bodega = t.bodega AND cod_seccion = t.cod_seccion AND cod_tramo = t.cod_tramo AND cod_fila = t.cod_fila AND cod_pos = t.cod_pos and cod_n = t.cod_n and cod_grupo = t.cod_grupo and cod_tipo = t.cod_tipo and cod_sec = t.cod_sec) and status_t is null) AS suma_cantidad2_pos
|
|
FROM
|
|
iptb00062 t
|
|
INNER JOIN intb00010 a ON t.bodega = a.cod_bodega AND t.cod_seccion = a.cod_seccion
|
|
INNER JOIN intb00043 b ON t.bodega = b.cod_bodega AND t.cod_seccion = b.cod_seccion AND t.cod_tramo = b.cod_tramo
|
|
INNER JOIN intb00045 c ON t.bodega = c.cod_bodega AND t.cod_seccion = c.cod_seccion AND t.cod_tramo = c.cod_tramo AND t.cod_fila = c.cod_fila
|
|
INNER JOIN intb00046 d ON t.bodega = d.cod_bodega AND t.cod_seccion = d.cod_seccion AND t.cod_tramo = d.cod_tramo AND t.cod_fila = d.cod_fila AND t.cod_pos = d.cod_pos
|
|
WHERE
|
|
(t.bodega = ? AND t.cod_n = ? AND t.cod_grupo = ? AND t.cod_tipo = ? AND t.cod_sec = ? AND t.status_t IS NULL)
|
|
GROUP BY
|
|
t.cod_seccion, t.cod_tramo, t.cod_fila, t.cod_pos, a.cod_seccion, a.descripcion, b.cod_tramo, b.descripcion, c.cod_fila, c.titulo, d.cod_pos, d.titulo, t.bodega, t.cod_n, t.cod_grupo, t.cod_tipo, t.cod_sec
|
|
ORDER BY
|
|
t.cod_seccion, t.cod_tramo, t.cod_fila, t.cod_pos;"
|
|
|
|
## El statement se prepara y el cursor se declara una sola vez;
|
|
## los codigos se pasan por parametro (USING) en cada llamada.
|
|
IF NOT prepTree THEN
|
|
PREPARE treestmt FROM consulta
|
|
DECLARE query CURSOR FOR treestmt
|
|
LET prepTree = TRUE
|
|
END IF
|
|
|
|
LET i = 2
|
|
LET z = 1
|
|
|
|
FOREACH query USING bodegaCont, cod_n1, cod_grupo1, cod_tipo1, cod_sec1 INTO Container[z].*
|
|
|
|
{IF container[z].existenciaSec <> 0
|
|
AND container[z].existenciaTram <> 0
|
|
AND container[z].existenciaFil <> 0
|
|
AND container[z].existenciaPos <> 0 THEN}
|
|
|
|
LET MirrorLocation[i] = Container[z]
|
|
LET i = i + 1
|
|
{END IF}
|
|
|
|
LET z = z + 1
|
|
|
|
END FOREACH
|
|
|
|
LET i = 2
|
|
|
|
IF MirrorLocation.getLength() > 0 THEN
|
|
LET prod1[j].descrip_esp = " UBICACIONES "
|
|
LET prod1[j].parent_id = firstID
|
|
LET prod1[j].child_id = firstID || "." || firstID
|
|
|
|
LET j = j + 1
|
|
END IF
|
|
|
|
WHILE i <= mirrorLocation.getLength()
|
|
|
|
IF mirrorLocation[i].seccion = mirrorLocation[i - 1].seccion THEN
|
|
|
|
IF mirrorLocation[i].tramo = mirrorLocation[i - 1].tramo THEN
|
|
|
|
IF mirrorLocation[i].fila = mirrorLocation[i - 1].fila THEN
|
|
|
|
IF mirrorLocation[i].posicion
|
|
= mirrorLocation[i - 1].posicion THEN
|
|
|
|
DISPLAY "nothing happened" --se supone que gracias al
|
|
--query esto nunca saldr�
|
|
ELSE
|
|
|
|
LET counterPos = counterPos + 1
|
|
|
|
LET prod1[j].estado =
|
|
mirrorLocation[i].seccion
|
|
|| " | "
|
|
|| mirrorLocation[i].cod_seccion,
|
|
" | " || mirrorLocation[i].cod_tramo,
|
|
" | " || mirrorLocation[i].cod_fila,
|
|
" | " || mirrorLocation[i].cod_pos
|
|
|
|
LET prod1[j].descrip_esp =
|
|
" ",
|
|
mirrorLocation[i].posicion,
|
|
" || Existencia:",
|
|
mirrorLocation[i].existenciaPos
|
|
LET prod1[j].parent_id =
|
|
firstID
|
|
|| "."
|
|
|| counterSec
|
|
|| "."
|
|
|| counterTram
|
|
|| "."
|
|
|| counterFil
|
|
LET prod1[j].child_id =
|
|
firstID
|
|
|| "."
|
|
|| counterSec
|
|
|| "."
|
|
|| counterTram
|
|
|| "."
|
|
|| counterFil
|
|
|| "."
|
|
|| counterPos
|
|
|
|
LET NextTree = TRUE
|
|
|
|
END IF
|
|
|
|
ELSE
|
|
|
|
IF nextTree = TRUE THEN
|
|
|
|
LET counterPos = 1
|
|
LET nextTree = FALSE
|
|
|
|
END IF
|
|
|
|
LET counterFil = counterFil + 1
|
|
|
|
LET prod1[j].estado =
|
|
mirrorLocation[i].seccion
|
|
|| " | "
|
|
|| mirrorLocation[i].cod_seccion
|
|
|| " | "
|
|
|| mirrorLocation[i].cod_tramo
|
|
|| " | "
|
|
|| mirrorLocation[i].cod_fila
|
|
LET prod1[j].descrip_esp =
|
|
" ",
|
|
mirrorLocation[i].fila,
|
|
" || Existencia:",
|
|
mirrorLocation[i].existenciaFil
|
|
LET prod1[j].parent_id =
|
|
firstID || "." || counterSec || "." || counterTram
|
|
LET prod1[j].child_id =
|
|
firstID
|
|
|| "."
|
|
|| counterSec
|
|
|| "."
|
|
|| counterTram
|
|
|| "."
|
|
|| counterFil
|
|
|
|
LET j = j + 1
|
|
|
|
LET prod1[j].estado =
|
|
prod1[j - 1].estado
|
|
|| " | "
|
|
|| mirrorLocation[i].cod_pos
|
|
LET prod1[j].descrip_esp =
|
|
" ",
|
|
mirrorLocation[i].posicion,
|
|
" || Existencia:",
|
|
mirrorLocation[i].existenciapos
|
|
LET prod1[j].parent_id = prod1[j - 1].child_id
|
|
LET prod1[j].child_id =
|
|
prod1[j - 1].child_id || "." || counterPos
|
|
|
|
LET nextTree2 = TRUE
|
|
|
|
END IF
|
|
|
|
ELSE
|
|
|
|
IF nextTree2 THEN
|
|
|
|
LET counterPos = 1
|
|
LET counterFil = 1
|
|
|
|
LET nextTree2 = FALSE
|
|
|
|
END IF
|
|
|
|
LET counterTram = counterTram + 1
|
|
|
|
LET prod1[j].estado =
|
|
mirrorLocation[i].seccion
|
|
|| " | "
|
|
|| mirrorLocation[i].cod_seccion
|
|
|| " | "
|
|
|| mirrorLocation[i].cod_tramo
|
|
|
|
LET prod1[j].descrip_esp =
|
|
" ",
|
|
mirrorLocation[i].tramo,
|
|
" || Existencia:",
|
|
mirrorLocation[i].existenciatram
|
|
LET prod1[j].parent_id = firstID || "." || counterSec
|
|
LET prod1[j].child_id =
|
|
firstID || "." || counterSec || "." || counterTram
|
|
|
|
LET j = j + 1
|
|
|
|
LET prod1[j].estado =
|
|
prod1[j - 1].estado || " | " || mirrorlocation[i].cod_fila
|
|
LET prod1[j].descrip_esp =
|
|
" ",
|
|
mirrorLocation[i].fila,
|
|
" || Existencia:",
|
|
mirrorLocation[i].existenciafil
|
|
|
|
LET prod1[j].parent_id = prod1[j - 1].child_id
|
|
LET prod1[j].child_id =
|
|
prod1[j - 1].child_id || "." || counterFil
|
|
|
|
LET j = j + 1
|
|
|
|
LET prod1[j].estado =
|
|
prod1[j - 1].estado || " | " || mirrorLocation[i].cod_pos
|
|
LET prod1[j].descrip_esp =
|
|
" ",
|
|
mirrorLocation[i].posicion,
|
|
" || Existencia:",
|
|
mirrorLocation[i].existenciapos
|
|
LET prod1[j].parent_id = prod1[j - 1].child_id
|
|
LET prod1[j].child_id =
|
|
prod1[j - 1].child_id || "." || counterPos
|
|
|
|
END IF
|
|
|
|
ELSE
|
|
|
|
LET counterSec = counterSec + 1
|
|
|
|
LET prod1[j].estado =
|
|
mirrorLocation[i].seccion
|
|
|| " | "
|
|
|| mirrorLocation[i].cod_seccion
|
|
LET prod1[j].descrip_esp =
|
|
" ",
|
|
mirrorLocation[i].seccion,
|
|
" || Existencia:",
|
|
mirrorLocation[i].existenciaSec
|
|
LET prod1[j].parent_id = firstID
|
|
LET prod1[j].child_id = firstID || "." || counterSec
|
|
|
|
LET j = j + 1
|
|
|
|
LET prod1[j].estado =
|
|
prod1[j - 1].estado || " | " || mirrorLocation[i].cod_tramo
|
|
LET prod1[j].descrip_esp =
|
|
" ",
|
|
mirrorLocation[i].tramo,
|
|
" || Existencia:",
|
|
mirrorLocation[i].existenciatram
|
|
LET prod1[j].parent_id = prod1[j - 1].child_id
|
|
LET prod1[j].child_id = prod1[j - 1].child_id || "." || firstID
|
|
|
|
LET j = j + 1
|
|
|
|
LET prod1[j].estado =
|
|
prod1[j - 1].estado || " | " || mirrorLocation[i].cod_fila
|
|
LET prod1[j].descrip_esp =
|
|
" ",
|
|
mirrorLocation[i].fila,
|
|
" || Existencia:",
|
|
mirrorLocation[i].existenciaFil
|
|
LET prod1[j].parent_id = prod1[j - 1].child_id
|
|
LET prod1[j].child_id = prod1[j - 1].child_id || "." || firstID
|
|
|
|
LET j = j + 1
|
|
|
|
LET prod1[j].estado =
|
|
prod1[j - 1].estado || " | " || mirrorLocation[i].cod_pos
|
|
LET prod1[j].descrip_esp =
|
|
" ",
|
|
mirrorLocation[i].posicion,
|
|
" || Existencia:",
|
|
mirrorLocation[i].existenciaPos
|
|
LET prod1[j].parent_id = prod1[j - 1].child_id
|
|
LET prod1[j].child_id = prod1[j - 1].child_id || "." || firstID
|
|
|
|
LET counterTram = 1
|
|
LET counterFil = 1
|
|
LET counterPos = 1
|
|
|
|
END IF
|
|
|
|
LET j = j + 1
|
|
LET i = i + 1
|
|
|
|
END WHILE
|
|
|
|
RETURN j
|
|
|
|
END FUNCTION
|
|
|
|
FUNCTION colocar_ubicacion(producto)
|
|
|
|
DEFINE producto RECORD
|
|
estado STRING,
|
|
cod_n SMALLINT,
|
|
cod_grupo SMALLINT,
|
|
cod_tipo SMALLINT,
|
|
cod_sec SMALLINT,
|
|
descrip_esp CHAR(180),
|
|
unidad_med LIKE iptb00002.unidad_med,
|
|
bodega CHAR(50),
|
|
existencia DECIMAL(12, 5),
|
|
cantidad_ordenes DEC(12, 5),
|
|
disponible DEC(12, 5),
|
|
reservado DEC(12, 5),
|
|
transito DEC(12, 5),
|
|
valorOrden DEC(12, 5),
|
|
parent_id, child_id STRING
|
|
END RECORD
|
|
|
|
DEFINE
|
|
answer, query STRING,
|
|
codigo_bodega INT
|
|
|
|
LET answer =
|
|
fgl_winquestion(
|
|
'COLOCAR UBICACION',
|
|
"Este Item no tiene ubicacion, desea colocar una ubicacion default?",
|
|
"yes",
|
|
"yes|no",
|
|
"question",
|
|
0)
|
|
|
|
PREPARE query3
|
|
FROM "SELECT cod_bodega FROM intb00009 WHERE descripcion = rtrim(?) AND status_t IS null "
|
|
|
|
EXECUTE query3 USING producto.bodega INTO codigo_bodega
|
|
|
|
PREPARE query4
|
|
FROM "Select sum(cantidad_1), sum(cantidad_2) FROM iptb00006 where cod_n = ? and cod_grupo = ? and cod_tipo = ?
|
|
and cod_sec = ? and bodega = ? and status_t is null"
|
|
|
|
LET producto.cantidad_ordenes = 0
|
|
LET producto.existencia = 0
|
|
|
|
EXECUTE query4
|
|
USING producto.cod_n,
|
|
producto.cod_grupo,
|
|
producto.cod_tipo,
|
|
producto.cod_sec,
|
|
codigo_bodega
|
|
INTO producto.cantidad_ordenes, producto.existencia
|
|
|
|
IF answer = "yes" THEN
|
|
|
|
INSERT INTO iptb00062(
|
|
num_doc,
|
|
fecha,
|
|
area,
|
|
cod_n,
|
|
cod_grupo,
|
|
cod_tipo,
|
|
cod_sec,
|
|
cod_mov,
|
|
bodega,
|
|
cod_seccion,
|
|
cod_tramo,
|
|
cod_fila,
|
|
cod_pos,
|
|
cantidad,
|
|
cantidad2,
|
|
status_t,
|
|
us_crea,
|
|
fech_crea,
|
|
us_mod,
|
|
fech_mod)
|
|
VALUES(99,
|
|
getdate(),
|
|
NULL,
|
|
producto.cod_n,
|
|
producto.cod_grupo,
|
|
producto.cod_tipo,
|
|
producto.cod_sec,
|
|
99,
|
|
codigo_bodega,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
producto.cantidad_ordenes,
|
|
producto.existencia,
|
|
NULL,
|
|
usuarios,
|
|
getdate(),
|
|
NULL,
|
|
NULL)
|
|
|
|
CALL fgl_winmessage(" ", "UBICACION ASIGNADA.", "info")
|
|
|
|
END IF
|
|
|
|
{DEJO ESTO COMENTADO EN CASO DE QUE QUERRAMOS HACER UN BOTON PARA
|
|
QUE LOS USUARIOS PUEDAN COLOCAR UBICACION A PRODUCTOS QUE NO TIENEN
|
|
|
|
DEFINE seccion, tramo, fila, posicion INT
|
|
|
|
DEFINE descripcion STRING
|
|
|
|
LET descripcion = producto.cod_n USING "<<<&",
|
|
"-",producto.cod_grupo USING "<<<<&",
|
|
"-",producto.cod_tipo USING "<<<<&",
|
|
"-",producto.cod_sec USING "<<<<&"
|
|
|
|
LET descripcion = producto.descrip_esp CLIPPED,"-(",descripcion CLIPPED,")"
|
|
|
|
OPEN WINDOW w1 WITH FORM "coloca_ubicacion"
|
|
|
|
DIALOG ATTRIBUTE(UNBUFFERED)
|
|
|
|
INPUT BY NAME seccion,tramo,fila,posicion, producto.can ATTRIBUTES(WITHOUT DEFAULTS)
|
|
BEFORE INPUT
|
|
CALL init_seccion(producto.bodega)
|
|
LET seccion = 0, tramo = 0, fila = 0, posicion = 0
|
|
|
|
ON CHANGE seccion
|
|
CALL init_tramo(producto.bodega, seccion)
|
|
|
|
ON CHANGE tramo
|
|
CALL init_fila(
|
|
producto.bodega,
|
|
seccion,
|
|
tramo)
|
|
|
|
ON CHANGE fila
|
|
CALL init_posicion(
|
|
producto.bodega,
|
|
seccion,
|
|
tramo,
|
|
fila)
|
|
|
|
|
|
END INPUT
|
|
|
|
END DIALOG
|
|
|
|
CLOSE WINDOW w1 }
|
|
|
|
END FUNCTION
|
|
|
|
################################################################################
|
|
## Ajuste de existencia en ubicaciones (iptb00062).
|
|
## La existencia real la tiene iptb00006. Esta funcion NO toca iptb00006:
|
|
## permite cuadrar el total de las ubicaciones del item en la bodega contra la
|
|
## existencia real, insertando en iptb00062 SOLO la diferencia por ubicacion,
|
|
## con cod_mov = 99 (existencia inicial). Asi no se adiciona existencia al item.
|
|
################################################################################
|
|
FUNCTION ajustar_ubicaciones(
|
|
p_cod_n,
|
|
p_cod_grupo,
|
|
p_cod_tipo,
|
|
p_cod_sec,
|
|
p_cod_bodega,
|
|
p_bodega_nombre,
|
|
p_descrip,
|
|
p_existencia_real)
|
|
|
|
DEFINE
|
|
p_cod_n, p_cod_grupo, p_cod_tipo, p_cod_sec INTEGER,
|
|
p_bodega_nombre CHAR(50),
|
|
p_descrip CHAR(180),
|
|
p_existencia_real DECIMAL(12, 5),
|
|
p_cod_bodega INTEGER,
|
|
k INTEGER,
|
|
total_corr DECIMAL(12, 5),
|
|
p_factor DECIMAL(12, 5),
|
|
guardado, hay_real BOOLEAN,
|
|
def_sec, def_tra, def_fila, def_pos INTEGER,
|
|
d_sec, d_tra, d_fila, d_pos VARCHAR(100),
|
|
p_codigo_str, p_desc_str, msg_txt, q STRING
|
|
|
|
## unidades = iptb00062.cantidad (lo que digita el usuario)
|
|
## existencia= iptb00062.cantidad2 (= unidades * factor_conv de iptb00001)
|
|
DEFINE loc DYNAMIC ARRAY OF RECORD
|
|
cod_seccion, cod_tramo, cod_fila, cod_pos INTEGER,
|
|
desc_seccion, desc_tramo, desc_fila, desc_pos VARCHAR(100),
|
|
existencia_act DECIMAL(12, 5),
|
|
unidades_act DECIMAL(12, 5),
|
|
unidades DECIMAL(12, 5),
|
|
existencia DECIMAL(12, 5)
|
|
END RECORD
|
|
|
|
LET guardado = FALSE
|
|
|
|
IF p_existencia_real IS NULL THEN
|
|
LET p_existencia_real = 0
|
|
END IF
|
|
|
|
## El codigo de bodega viene del arreglo bodegas[] (ya calculado por
|
|
## LlenarHijos, igual que lo usa la opcion 'Ubicar'). Solo como respaldo,
|
|
## si no viniera, se resuelve por la descripcion.
|
|
DISPLAY "Dato Bodega: ",p_cod_bodega
|
|
IF p_cod_bodega IS NULL OR p_cod_bodega <= 0 THEN
|
|
SELECT cod_bodega
|
|
INTO p_cod_bodega
|
|
FROM intb00009
|
|
WHERE descripcion = RTRIM(p_cod_bodega)
|
|
AND status_t IS NULL
|
|
END IF
|
|
|
|
IF p_cod_bodega IS NULL THEN
|
|
CALL fgl_winmessage(
|
|
"ERROR", "No se pudo determinar la bodega del producto.", "stop")
|
|
RETURN FALSE
|
|
END IF
|
|
|
|
## El usuario debe tener acceso a la bodega (igual que la opcion de ubicar).
|
|
SELECT UNIQUE a.usuario
|
|
FROM iptb00048 a
|
|
WHERE a.bodega = p_cod_bodega
|
|
AND a.usuario = usuarios
|
|
|
|
IF STATUS = NOTFOUND THEN
|
|
CALL msg(503)
|
|
RETURN FALSE
|
|
END IF
|
|
|
|
## Factor de conversion del item (unidades -> existencia), igual que
|
|
## usa BuscarData/InsertaUbicacionDH: existencia = unidades * factor.
|
|
LET p_factor = NULL
|
|
SELECT factor_conv
|
|
INTO p_factor
|
|
FROM iptb00001
|
|
WHERE cod_n = p_cod_n
|
|
AND cod_grupo = p_cod_grupo
|
|
AND cod_tipo = p_cod_tipo
|
|
AND cod_sec = p_cod_sec
|
|
AND status_t IS NULL
|
|
|
|
IF p_factor IS NULL OR p_factor = 0 THEN
|
|
LET p_factor = 1
|
|
END IF
|
|
|
|
## Cargar TODAS las ubicaciones del item en la bodega (LEFT JOIN para que
|
|
## tambien aparezcan las filas placeholder 0/0/0/0 sin descripcion, y asi
|
|
## el total refleje realmente SUM(cantidad2) de iptb00062).
|
|
IF NOT prepAjuste THEN
|
|
LET q =
|
|
"SELECT t.cod_seccion, t.cod_tramo, t.cod_fila, t.cod_pos,",
|
|
" RTRIM(a.descripcion), RTRIM(b.descripcion), RTRIM(c.titulo), RTRIM(d.titulo),",
|
|
" ISNULL(SUM(t.cantidad2),0), ISNULL(SUM(t.cantidad),0)",
|
|
" FROM iptb00062 t",
|
|
" LEFT JOIN intb00010 a ON t.bodega=a.cod_bodega AND t.cod_seccion=a.cod_seccion",
|
|
" LEFT JOIN intb00043 b ON t.bodega=b.cod_bodega AND t.cod_seccion=b.cod_seccion AND t.cod_tramo=b.cod_tramo",
|
|
" LEFT JOIN intb00045 c ON t.bodega=c.cod_bodega AND t.cod_seccion=c.cod_seccion AND t.cod_tramo=c.cod_tramo AND t.cod_fila=c.cod_fila",
|
|
" LEFT JOIN intb00046 d ON t.bodega=d.cod_bodega AND t.cod_seccion=d.cod_seccion AND t.cod_tramo=d.cod_tramo AND t.cod_fila=d.cod_fila AND t.cod_pos=d.cod_pos",
|
|
" WHERE t.bodega=? AND t.cod_n=? AND t.cod_grupo=? AND t.cod_tipo=? AND t.cod_sec=? AND t.status_t IS NULL",
|
|
" GROUP BY t.cod_seccion,t.cod_tramo,t.cod_fila,t.cod_pos,a.descripcion,b.descripcion,c.titulo,d.titulo",
|
|
" ORDER BY t.cod_seccion,t.cod_tramo,t.cod_fila,t.cod_pos"
|
|
PREPARE stmt_ajuste FROM q
|
|
DECLARE cur_ajuste CURSOR FOR stmt_ajuste
|
|
LET prepAjuste = TRUE
|
|
END IF
|
|
|
|
CALL loc.clear()
|
|
LET k = 1
|
|
FOREACH cur_ajuste
|
|
USING p_cod_bodega, p_cod_n, p_cod_grupo, p_cod_tipo, p_cod_sec
|
|
INTO loc[k].cod_seccion,
|
|
loc[k].cod_tramo,
|
|
loc[k].cod_fila,
|
|
loc[k].cod_pos,
|
|
loc[k].desc_seccion,
|
|
loc[k].desc_tramo,
|
|
loc[k].desc_fila,
|
|
loc[k].desc_pos,
|
|
loc[k].existencia_act,
|
|
loc[k].unidades_act
|
|
|
|
IF loc[k].existencia_act IS NULL THEN
|
|
LET loc[k].existencia_act = 0
|
|
END IF
|
|
IF loc[k].unidades_act IS NULL THEN
|
|
LET loc[k].unidades_act = 0
|
|
END IF
|
|
IF loc[k].desc_seccion IS NULL THEN
|
|
LET loc[k].desc_seccion = "(sin ubicar)"
|
|
END IF
|
|
IF loc[k].desc_tramo IS NULL THEN
|
|
LET loc[k].desc_tramo = "-"
|
|
END IF
|
|
IF loc[k].desc_fila IS NULL THEN
|
|
LET loc[k].desc_fila = "-"
|
|
END IF
|
|
IF loc[k].desc_pos IS NULL THEN
|
|
LET loc[k].desc_pos = "-"
|
|
END IF
|
|
## Las UNIDADES arrancan en las actuales y la CANTIDAD (existencia) se
|
|
## calcula desde ya con el factor (unidades * factor), no desde el
|
|
## cantidad2 guardado (que puede estar descuadrado, p.ej. en 0).
|
|
LET loc[k].unidades = loc[k].unidades_act
|
|
LET loc[k].existencia = loc[k].unidades_act * p_factor
|
|
LET k = k + 1
|
|
END FOREACH
|
|
|
|
## Si el item NO tiene ninguna ubicacion REAL en la bodega (nunca tuvo
|
|
## transacciones en iptb00062, o solo tiene el placeholder 0/0/0/0 que crea
|
|
## "adicionar sin existencia"), se presenta la ubicacion por defecto
|
|
## configurada en la tabla companias para que el usuario cargue ahi.
|
|
LET hay_real = FALSE
|
|
FOR k = 1 TO loc.getLength()
|
|
IF loc[k].cod_seccion > 0
|
|
OR loc[k].cod_tramo > 0
|
|
OR loc[k].cod_fila > 0
|
|
OR loc[k].cod_pos > 0 THEN
|
|
LET hay_real = TRUE
|
|
EXIT FOR
|
|
END IF
|
|
END FOR
|
|
|
|
IF NOT hay_real THEN
|
|
INITIALIZE def_sec, def_tra, def_fila, def_pos TO NULL
|
|
SELECT cod_seccion, cod_tramo, cod_fila, cod_pos
|
|
INTO def_sec, def_tra, def_fila, def_pos
|
|
FROM companias
|
|
|
|
IF def_sec IS NOT NULL THEN
|
|
## Descripciones de la ubicacion por defecto (si estan en catalogo).
|
|
LET d_sec = NULL
|
|
SELECT RTRIM(descripcion) INTO d_sec FROM intb00010
|
|
WHERE cod_bodega = p_cod_bodega AND cod_seccion = def_sec
|
|
LET d_tra = NULL
|
|
SELECT RTRIM(descripcion) INTO d_tra FROM intb00043
|
|
WHERE cod_bodega = p_cod_bodega AND cod_seccion = def_sec
|
|
AND cod_tramo = def_tra
|
|
LET d_fila = NULL
|
|
SELECT RTRIM(titulo) INTO d_fila FROM intb00045
|
|
WHERE cod_bodega = p_cod_bodega AND cod_seccion = def_sec
|
|
AND cod_tramo = def_tra AND cod_fila = def_fila
|
|
LET d_pos = NULL
|
|
SELECT RTRIM(titulo) INTO d_pos FROM intb00046
|
|
WHERE cod_bodega = p_cod_bodega AND cod_seccion = def_sec
|
|
AND cod_tramo = def_tra AND cod_fila = def_fila
|
|
AND cod_pos = def_pos
|
|
|
|
## Se AGREGA como una fila mas (no se pierde ningun placeholder).
|
|
LET k = loc.getLength() + 1
|
|
LET loc[k].cod_seccion = def_sec
|
|
LET loc[k].cod_tramo = def_tra
|
|
LET loc[k].cod_fila = def_fila
|
|
LET loc[k].cod_pos = def_pos
|
|
LET loc[k].desc_seccion = d_sec
|
|
LET loc[k].desc_tramo = d_tra
|
|
LET loc[k].desc_fila = d_fila
|
|
LET loc[k].desc_pos = d_pos
|
|
IF loc[k].desc_seccion IS NULL THEN
|
|
LET loc[k].desc_seccion = "SEC " || def_sec
|
|
END IF
|
|
IF loc[k].desc_tramo IS NULL THEN
|
|
LET loc[k].desc_tramo = "TR " || def_tra
|
|
END IF
|
|
IF loc[k].desc_fila IS NULL THEN
|
|
LET loc[k].desc_fila = "FL " || def_fila
|
|
END IF
|
|
IF loc[k].desc_pos IS NULL THEN
|
|
LET loc[k].desc_pos = "POS " || def_pos
|
|
END IF
|
|
LET loc[k].existencia_act = 0
|
|
LET loc[k].unidades_act = 0
|
|
LET loc[k].unidades = 0
|
|
LET loc[k].existencia = 0
|
|
END IF
|
|
END IF
|
|
|
|
## Si aun asi no hay nada para mostrar (sin ubicaciones y sin default).
|
|
IF loc.getLength() = 0 THEN
|
|
CALL fgl_winmessage(
|
|
"INFO",
|
|
"Este item no tiene ubicaciones en esta bodega y no hay ubicacion por defecto configurada en companias. Use la opcion 'Ubicar' primero.",
|
|
"info")
|
|
RETURN FALSE
|
|
END IF
|
|
|
|
LET p_codigo_str =
|
|
(p_cod_n USING "<<<<<&") CLIPPED, " - ",
|
|
(p_cod_grupo USING "<<<<<&") CLIPPED, " - ",
|
|
(p_cod_tipo USING "<<<<<&") CLIPPED, " - ",
|
|
(p_cod_sec USING "<<<<<&") CLIPPED
|
|
LET p_desc_str = p_descrip CLIPPED
|
|
|
|
OPEN WINDOW w_ajuste WITH FORM "ipfmcs004b"
|
|
|
|
DISPLAY p_codigo_str TO pcodigo
|
|
DISPLAY p_desc_str TO pdesc
|
|
DISPLAY p_bodega_nombre CLIPPED TO pbodega
|
|
DISPLAY p_existencia_real TO ereal
|
|
|
|
INPUT ARRAY loc FROM sr_loc.*
|
|
ATTRIBUTES(WITHOUT DEFAULTS,
|
|
APPEND ROW = FALSE,
|
|
INSERT ROW = FALSE,
|
|
DELETE ROW = FALSE,
|
|
UNBUFFERED)
|
|
|
|
BEFORE INPUT
|
|
LET total_corr = 0
|
|
FOR k = 1 TO loc.getLength()
|
|
LET total_corr = total_corr + loc[k].existencia
|
|
END FOR
|
|
DISPLAY total_corr TO tubic
|
|
DISPLAY p_existencia_real - total_corr TO pdif
|
|
|
|
ON CHANGE unidades
|
|
## La existencia (cantidad2) se calcula multiplicando por el factor.
|
|
IF loc[arr_curr()].unidades IS NULL THEN
|
|
LET loc[arr_curr()].unidades = 0
|
|
END IF
|
|
LET loc[arr_curr()].existencia =
|
|
loc[arr_curr()].unidades * p_factor
|
|
|
|
LET total_corr = 0
|
|
FOR k = 1 TO loc.getLength()
|
|
LET total_corr = total_corr + loc[k].existencia
|
|
END FOR
|
|
DISPLAY total_corr TO tubic
|
|
DISPLAY p_existencia_real - total_corr TO pdif
|
|
|
|
ON ACTION accept
|
|
LET total_corr = 0
|
|
FOR k = 1 TO loc.getLength()
|
|
IF loc[k].existencia IS NULL THEN
|
|
LET loc[k].existencia = 0
|
|
END IF
|
|
LET total_corr = total_corr + loc[k].existencia
|
|
END FOR
|
|
|
|
IF total_corr <> p_existencia_real THEN
|
|
LET msg_txt =
|
|
"El total de las ubicaciones (",
|
|
total_corr,
|
|
") debe ser igual a la existencia real (",
|
|
p_existencia_real,
|
|
"). Diferencia: ",
|
|
(p_existencia_real - total_corr)
|
|
CALL fgl_winmessage("VALIDACION", msg_txt, "stop")
|
|
CONTINUE INPUT
|
|
END IF
|
|
|
|
TRY
|
|
BEGIN WORK
|
|
FOR k = 1 TO loc.getLength()
|
|
## Solo se registra la DIFERENCIA por ubicacion, con cod_mov 99.
|
|
## cantidad = delta de UNIDADES, cantidad2 = delta de existencia.
|
|
IF loc[k].existencia <> loc[k].existencia_act
|
|
OR loc[k].unidades <> loc[k].unidades_act THEN
|
|
INSERT INTO iptb00062(
|
|
num_doc,
|
|
fecha,
|
|
area,
|
|
cod_n,
|
|
cod_grupo,
|
|
cod_tipo,
|
|
cod_sec,
|
|
cod_mov,
|
|
bodega,
|
|
cod_seccion,
|
|
cod_tramo,
|
|
cod_fila,
|
|
cod_pos,
|
|
cantidad,
|
|
cantidad2,
|
|
status_t,
|
|
us_crea,
|
|
fech_crea,
|
|
us_mod,
|
|
fech_mod)
|
|
VALUES(99,
|
|
getdate(),
|
|
NULL,
|
|
p_cod_n,
|
|
p_cod_grupo,
|
|
p_cod_tipo,
|
|
p_cod_sec,
|
|
99,
|
|
p_cod_bodega,
|
|
loc[k].cod_seccion,
|
|
loc[k].cod_tramo,
|
|
loc[k].cod_fila,
|
|
loc[k].cod_pos,
|
|
loc[k].unidades - loc[k].unidades_act,
|
|
loc[k].existencia - loc[k].existencia_act,
|
|
NULL,
|
|
usuarios,
|
|
getdate(),
|
|
NULL,
|
|
NULL)
|
|
END IF
|
|
END FOR
|
|
COMMIT WORK
|
|
LET guardado = TRUE
|
|
CALL fgl_winmessage(
|
|
" ", "AJUSTE DE UBICACIONES APLICADO.", "info")
|
|
EXIT INPUT
|
|
CATCH
|
|
ROLLBACK WORK
|
|
CALL fgl_winmessage(
|
|
"ERROR", "NO SE PUDO APLICAR EL AJUSTE.", "stop")
|
|
END TRY
|
|
|
|
ON ACTION cancel
|
|
LET guardado = FALSE
|
|
EXIT INPUT
|
|
END INPUT
|
|
|
|
CLOSE WINDOW w_ajuste
|
|
|
|
RETURN guardado
|
|
|
|
END FUNCTION
|
|
|
|
################################################################################
|
|
## Recarga el arbol de productos/ubicaciones en pantalla reutilizando el cursor
|
|
## 'accion' ya preparado. Se usa tras aplicar un ajuste de ubicaciones para que
|
|
## el usuario vea las existencias actualizadas sin volver a buscar.
|
|
################################################################################
|
|
FUNCTION recargar_arbol()
|
|
DEFINE
|
|
pcantidadConduce, pexistencia DEC(12, 5),
|
|
codigo_act, codigo_ant VARCHAR(50),
|
|
idx, j, z, bodegaCont INT
|
|
|
|
LET idx = 1
|
|
LET j = 0
|
|
LET z = 1
|
|
CALL prod1.clear()
|
|
CALL bodegas.clear()
|
|
CALL bodega_fila.clear()
|
|
CALL load_ubicaciones.clear()
|
|
LET codigo_ant = '0'
|
|
LET codigo_act = '0'
|
|
|
|
FOREACH accion INTO prod1[idx].*
|
|
LET ubicaciones = 0
|
|
LET codigo_act =
|
|
prod1[idx].cod_n USING "&&&&&",
|
|
prod1[idx].cod_grupo USING "&&&&&",
|
|
prod1[idx].cod_tipo USING "&&&&&",
|
|
prod1[idx].cod_sec USING "&&&&&&&&"
|
|
|
|
LET prod1[idx].estado = NULL
|
|
SELECT UNIQUE a.cod_sec
|
|
FROM iptb00050 a
|
|
WHERE a.cod_n = prod1[idx].cod_n
|
|
AND a.cod_grupo = prod1[idx].cod_grupo
|
|
AND a.cod_tipo = prod1[idx].cod_tipo
|
|
AND a.cod_sec = prod1[idx].cod_sec
|
|
|
|
IF STATUS <> NOTFOUND THEN
|
|
LET prod1[idx].estado = "information.png"
|
|
END IF
|
|
IF prod1[idx].existencia IS NULL THEN
|
|
LET prod1[idx].existencia = 0
|
|
END IF
|
|
|
|
LET prod1[idx].cantidad_ordenes = 0
|
|
|
|
IF codigo_ant <> codigo_act THEN
|
|
LET codigo_ant =
|
|
prod1[idx].cod_n USING "&&&&",
|
|
prod1[idx].cod_grupo USING "&&&&",
|
|
prod1[idx].cod_tipo USING "&&&&",
|
|
prod1[idx].cod_sec USING "&&&&&&"
|
|
|
|
CALL disponibles(
|
|
prod1[idx].cod_n,
|
|
prod1[idx].cod_grupo,
|
|
prod1[idx].cod_tipo,
|
|
prod1[idx].cod_sec,
|
|
datos_cons.fech_fi)
|
|
RETURNING prod1[idx].cantidad_ordenes,
|
|
pcantidadConduce,
|
|
prod1[idx].transito,
|
|
pexistencia,
|
|
prod1[idx].reservado,
|
|
prod1[idx].valorOrden
|
|
|
|
LET prod1[idx].cantidad_ordenes =
|
|
prod1[idx].cantidad_ordenes - pcantidadConduce
|
|
|
|
IF prod1[idx].cantidad_ordenes = 0 THEN
|
|
LET prod1[idx].valorOrden = 0
|
|
END IF
|
|
END IF
|
|
IF prod1[idx].existencia IS NULL THEN
|
|
LET prod1[idx].existencia = 0
|
|
END IF
|
|
IF prod1[idx].cantidad_ordenes IS NULL THEN
|
|
LET prod1[idx].cantidad_ordenes = 0
|
|
END IF
|
|
IF prod1[idx].disponible IS NULL THEN
|
|
LET prod1[idx].disponible = 0
|
|
END IF
|
|
LET prod1[idx].disponible =
|
|
pexistencia - prod1[idx].cantidad_ordenes - prod1[idx].reservado
|
|
LET productos[idx].producto =
|
|
prod1[idx].cod_n USING "&&&&",
|
|
prod1[idx].cod_grupo USING "&&&&",
|
|
prod1[idx].cod_tipo USING "&&&&",
|
|
prod1[idx].cod_sec USING "&&&&&&",
|
|
" ",
|
|
prod1[idx].descrip_esp
|
|
LET productos[idx].bodega = prod1[idx].bodega
|
|
LET productos[idx].existencia = prod1[idx].existencia
|
|
LET productos[idx].parent = prod1[idx].bodega
|
|
|
|
CALL LlenarHijos(prod1[idx].*) RETURNING bodegaCont, ubicaciones
|
|
|
|
LET bodegas[z] = bodegacont
|
|
LET bodega_fila[idx] = bodegacont
|
|
LET load_ubicaciones[z] = ubicaciones
|
|
LET z = z + 1
|
|
|
|
LET INT_FLAG = FALSE
|
|
|
|
IF ubicaciones > 0 THEN
|
|
LET j = idx + 1
|
|
LET INT_FLAG = TRUE
|
|
|
|
LET prod1[idx].parent_id = NULL
|
|
LET prod1[idx].child_id = 1
|
|
|
|
CALL treeFunction(
|
|
j,
|
|
prod1[idx].cod_n,
|
|
prod1[idx].cod_grupo,
|
|
prod1[idx].cod_tipo,
|
|
prod1[idx].cod_sec,
|
|
bodegaCont,
|
|
prod1[idx].existencia)
|
|
RETURNING j
|
|
|
|
END IF
|
|
|
|
IF INT_FLAG THEN
|
|
LET idx = j
|
|
ELSE
|
|
LET idx = idx + 1
|
|
END IF
|
|
|
|
INITIALIZE ubicaciones TO NULL
|
|
|
|
END FOREACH
|
|
|
|
IF idx = 1 THEN
|
|
CALL msg(3)
|
|
END IF
|
|
|
|
END FUNCTION
|
|
|
|
FUNCTION reporteData()
|
|
DEFINE
|
|
j INT,
|
|
pcosto, valorcosto, pprecio, valorprecio DEC(12, 2),
|
|
xcodigo VARCHAR(100)
|
|
LET r_filename = "ipprcs004.4rp"
|
|
FOR j = 1 TO prod1.getLength()
|
|
IF prod1[j].cod_n IS NOT NULL THEN
|
|
IF j = 1 THEN
|
|
IF fgl_report_loadCurrentSettings(
|
|
r_filename) THEN -- load the .4rp file
|
|
CALL seleccionarSalida() RETURNING r_output
|
|
LET preview = 1
|
|
CALL fgl_report_selectDevice(r_output) -- changing default
|
|
CALL fgl_report_selectPreview(preview) -- changing default
|
|
LET handler =
|
|
fgl_report_commitCurrentSettings() -- commit changes
|
|
|
|
IF handler IS NOT NULL THEN -- report engine was configured ok
|
|
START REPORT datarp06 TO XML HANDLER HANDLER
|
|
ELSE
|
|
EXIT FOR
|
|
END IF
|
|
ELSE
|
|
EXIT FOR
|
|
END IF
|
|
END IF
|
|
#BUSCA COSTO STD
|
|
|
|
LET valorcosto = 0
|
|
SELECT AVG(a.material + a.labor + a.gastos)
|
|
INTO pcosto
|
|
FROM iptb00004 a
|
|
WHERE a.ano = YEAR(TODAY)
|
|
AND a.mes_fin = 12
|
|
AND a.cod_n = prod1[j].cod_n
|
|
AND a.cod_grupo = prod1[j].cod_grupo
|
|
AND a.cod_tipo = prod1[j].cod_tipo
|
|
AND a.cod_sec = prod1[j].cod_sec
|
|
AND a.status_t IS NULL
|
|
|
|
LET valorcosto = prod1[j].existencia * pcosto
|
|
SELECT ISNULL(AVG(a.precio), 0)
|
|
INTO pprecio
|
|
FROM vetb00025 a
|
|
WHERE a.ventas = '1'
|
|
AND a.cod_n = prod1[j].cod_n
|
|
AND a.cod_grupo = prod1[j].cod_grupo
|
|
AND a.cod_tipo = prod1[j].cod_tipo
|
|
AND a.cod_sec = prod1[j].cod_sec
|
|
AND a.status_t IS NULL
|
|
LET valorprecio = pprecio * prod1[j].existencia
|
|
|
|
LET xcodigo =
|
|
prod1[j].cod_n USING "<<<<<",
|
|
"-",
|
|
prod1[j].cod_tipo USING "<<<<<",
|
|
"-",
|
|
prod1[j].cod_grupo USING "<<<<<",
|
|
"-",
|
|
prod1[j].cod_sec USING "<<<<<"
|
|
OUTPUT TO REPORT DATARP06(
|
|
xcodigo, prod1[j].*, valorcosto, pprecio, valorprecio)
|
|
END IF
|
|
END FOR
|
|
FINISH REPORT datarp06
|
|
|
|
END FUNCTION
|
|
REPORT datarp06(pcodigo, x, xvalorcosto, pprecio, valorprecio)
|
|
DEFINE
|
|
x RECORD
|
|
estado VARCHAR(20),
|
|
cod_n SMALLINT,
|
|
cod_grupo SMALLINT,
|
|
cod_tipo SMALLINT,
|
|
cod_sec SMALLINT,
|
|
descrip_esp CHAR(180),
|
|
unidad_med LIKE iptb00002.unidad_med,
|
|
bodega CHAR(50),
|
|
existencia DECIMAL(12, 5),
|
|
cantidad_ordenes DEC(12, 5),
|
|
disponible DEC(12, 5),
|
|
reservado DEC(12, 5),
|
|
transito DEC(12, 5),
|
|
valorOrden DEC(16, 5),
|
|
parent_id, child_id VARCHAR(20)
|
|
END RECORD,
|
|
pcodigo VARCHAR(100),
|
|
xvalorcosto,
|
|
tvalororden,
|
|
tvalorcosto,
|
|
tvalorprecio,
|
|
pexistencia,
|
|
pcantidadorden,
|
|
pvalororden,
|
|
pvalorcosto,
|
|
pprecio,
|
|
valorprecio
|
|
DEC(12, 2),
|
|
tiempo VARCHAR(5)
|
|
ORDER BY pcodigo
|
|
FORMAT
|
|
AFTER GROUP OF pcodigo
|
|
LET tiempo = TIME
|
|
LET pvalororden = GROUP SUM(x.valorORden)
|
|
LET pexistencia = GROUP SUM(x.existencia)
|
|
LET pcantidadorden = GROUP SUM(x.cantidad_ordenes)
|
|
LET pvalorcosto = GROUP SUM(xvalorcosto)
|
|
|
|
PRINTX x.*,
|
|
xvalorcosto,
|
|
tiempo,
|
|
pvalororden,
|
|
pexistencia,
|
|
pcantidadorden,
|
|
pvalorcosto,
|
|
pprecio,
|
|
valorprecio
|
|
|
|
ON LAST ROW
|
|
LET tvalororden = SUM(x.cantidad_ordenes)
|
|
LET tvalorcosto = SUM(x.existencia)
|
|
LET tvalorprecio = SUM(valorprecio)
|
|
PRINTX tvalororden, tvalorcosto, tvalorprecio
|
|
END REPORT
|
|
|
|
FUNCTION extract_value(criterio, campo)
|
|
|
|
DEFINE criterio, campo VARCHAR(500)
|
|
DEFINE tok, tok2 base.StringTokenizer
|
|
DEFINE token, VALUE, token2 VARCHAR(200)
|
|
DEFINE idx INTEGER
|
|
|
|
LET tok = base.StringTokenizer.create(criterio, " ")
|
|
LET value = ""
|
|
LET campo = '*', campo, '*'
|
|
LET idx = 1
|
|
|
|
WHILE tok.hasMoreTokens()
|
|
LET token = tok.nextToken()
|
|
|
|
-- Verifica si el token comienza con el campo
|
|
IF token MATCHES campo THEN
|
|
|
|
LET tok2 = base.StringTokenizer.create(token, "=")
|
|
|
|
WHILE tok2.hasMoreTokens()
|
|
LET token2 = tok2.nextToken()
|
|
DISPLAY token2
|
|
|
|
IF idx = 2 THEN
|
|
|
|
LET VALUE = token2
|
|
EXIT WHILE
|
|
|
|
END IF
|
|
|
|
LET idx = idx + 1
|
|
|
|
END WHILE
|
|
|
|
END IF
|
|
END WHILE
|
|
|
|
DISPLAY VALUE
|
|
RETURN VALUE
|
|
|
|
END FUNCTION
|