Estimados Colegas

Tengo un problema con las fechas de creacion, de modificacion y acceso a 
un archivo.
Utiizando la funcion directory() me devuelve un arreglo con la 
informacion que necesito, pero mi problema es el siguiente:

Cada dia en las oficinas borro y creo una tabla llamada precios.dbf
Asi, que en teoria, precios.dbf debe tener las misma fecha de creacion, 
modificacion y accesso.

Bueno, todos los dias ya en la tarde mi sistema empaca o crea un zip con 
algunas tablas incluyendo precios.dbf y las sube al ftp.
Para el dia siguiente mi punto de venta bajar ese archivo zip.
Una vez bajado y desempacado me doy cuenta que las fechas de creacion de 
precios.dbf es la del dia actual y no la del dia de ayer la cual fue 
creada, la fecha de modificacion es la del dia de ayer y la fecha de 
acceso es la del dia de hoy


Puede ser problema del zip,

Alguien tiene algun comentario.

Saludos
Osvaldo Ramirez

Estimados

Algo curioso


Estoy creando un archivo xpf con hora de las 7:00pm, y si lo crea bien
pero cuando lo comprimo y descomprimo al ver la fecha y hora del 
archivo. Me pone fecha de un dia despues y hora de la 1:00am

Actualmente estoy usando una clase de Brent azip.
Intentare probar con las clases de Phil y Andreas, para ver si estas, me 
  guardan bien las fechas y las ponen igual al momento de restaurarlas.

Queria yo basar mis actualizaciones de archivos entre el servidor y los 
puntos de venta, en base a las fechas de creacion y modificacion, pero 
creo que no es conveniente, ya que por algun motivo estas se cambian.

Saludos
Osvaldo Ramirez

Bueno

En resumen

1.- Como puedo conservar las fechas de creacion de un  archivo el cual 
se comprime un dia y se descomprime al siguiente dia en otra pc. Y ...
Al momento de copiar dicho archivo descomprimido a otra carpeta, tambien 
conservar la misma fecha de creacion inicial


Saludos
Osvaldo Ramirez

YO UTILIZO LA ZIP32.DLL Y TENGO EL MISMO PROBLEMA, LA SOLUCION
RENOMBRA LA DBF CON LA FECHA 20060905-15:00.DBF CON ESTO ESTOY SEGURO
DE LA FECHA DE CREACION Y COMO VALOR AGREGADO NO CORRO EL RIESGO DE
PISAR UNA TABLA (ACTUALIZACION) ANTERIOR, ADEMAS DE QUE ME QUEDA UN
BACKUP DE CADA TRANSFERENCIA Y/O BACKUP, SEGUN EL USO.

PERDON, SE ESCAPO UN ERROR NO ES : ES _ EN LA HORA, DE ESTA FORMA SI
ORDENAS EL RETORNO DE DIRECTORY, EL ULTIMO ELEMENTO ES LA TABLA QUE
NECESITAS.

YO UTILIZO LA ZIP32.DLL Y TENGO EL MISMO PROBLEMA, LA SOLUCION
RENOMBRA LA DBF CON LA FECHA 20060905-15_00.DBF CON ESTO ESTOY SEGURO
DE LA FECHA DE CREACION Y COMO VALOR AGREGADO NO CORRO EL RIESGO DE
PISAR UNA TABLA (ACTUALIZACION) ANTERIOR, ADEMAS DE QUE ME QUEDA UN
BACKUP DE CADA TRANSFERENCIA Y/O BACKUP, SEGUN EL USO.

Hola Osvaldo,

He leido tu mensaje y creo que el problema reside en otro lugar.

En apariencia tu estrategia apunta a resolver una cuestin anterior que es 
el sincronismo de tablas.
Ese dilema es generalmente resuelto por medio de las siguientes estrategias:

1.1) La presencia de la tabla a sincronizar en cierto directorio.

1.2)
Agregando los campos:
             { "DSYNC", "D", 8, 0 },;    Fecha de modificacin de dato a 
sincronizar.
             { "TSYNC", "C", 8, 0 },;    Hora de modificacin de dato a 
sincronizar.
             { "SYNCD", "L", 1, 0 },;   Est sincronizado? 
(Predeterminado, .F.)
             { "SYNCF", "C", fcount()-4, 0 };  un byte por campo a 
sincronizar.
Las dos tablas a sincronizar deben tener:



Cmo se usa SYNCF?

Sea la tabla: (tomada de la documentacin de Xbase++)
      LOCAL aStructure := { ;
              { "EMPLOYEENO"   , "C",  6, 0 }, ;    1
              { "LASTNAME"     , "C", 20, 0 }, ;       2
              { "FIRSTNAME"    , "C", 20, 0 }, ;       3
              { "BIRTHDATE"    , "D",  8, 0 }, ;        4
              { "GENDER"       , "L",  1, 0 }, ;           5
              { "DEPARTMENT"   , "C", 20, 0 }, ;   6
              { "INCOME"       , "N",  9, 2 }, ;         7
              { "STREET"       , "C", 30, 0 }, ;          8
              { "CITY"         , "C", 30, 0 }, ;             9
              { "STATE"        , "C",  2, 0 }, ;            10
              { "ZIP"          , "C",  5, 0 }, ;              11
              { "TELEPHONE"    , "C", 15, 0 }, ;    12
              { "MEMO"         , "M", 10, 0 },  ;   13
             { "DSYNC", "D", 8, 0 },;    Fecha de modificacin de dato a 
sincronizar.
             { "TSYNC", "C", 8, 0 },;    Hora de modificacin de dato a 
sincronizar.
             { "SYNCD", "L", 1, 0 },;   Est sincronizado? 
(Predeterminado, .F.)
             { "SYNCF", "C", 13, 0 };  un byte por campo a sincronizar.
            }

      DbCreate( "EMPLOYEE", aStructure, "DBFNTX" )

Si deseamos sincronizar slo INCOME, STREET, CITY, STATE, ZIP y MEMO,  el 
campo SYNCF contendr:
SPACE(6)+"XXXXX"+SPACE(1)+"X"
He escrito de esta forma para resaltar las seis primeras posiciones en 
blanco que son campos que no se sincronizarn.
Las  "X" se corresponden con cada campo a sincronizar.

En el caso del campo SYNCF simplemente se sincroniza el contenido del campo 
si:

SUBSTR(mitabla->SYNCF, nPos, 1) == "X"  ( o cualquier otro smbolo 
apropiado )

entonces FieldPut( nPos, (cSyncTabla)->(FieldGet(FieldPos( nPos)) ) ) 
produce la actualizacin del campo a sincronizar con la tabla.

1.3) Puede tenerse una variable guardada en disco cuyo nombre sea el mismo 
de la tabla.
En esa variable se tienen predeterminados los items a sincronizar.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 Pre condicin:
 --------------
 cTable es ALIAS() de una tabla actualmente en uso.
 cSyncTable es el ALIAS() en uso de una tabla de sincronismo para cTable.

 Nota: Este cdigo no est libre de errores y no ha sido diseado con un 
propsito en especial
 ni para cumplir ciertos requerimientos especficos.
 Es un ejemplo sobre estrategias que pueden seguirse para sincronizar 
tablas.
 En este ejemplo se usa un campo de la tabla como elemento de 
sincronizacin.
PROCEDURE SyncTable( cTable,  cSyncTable)

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
LOCAL nLen := 0
LOCAL nPos := 0

  DBSelectArea( cTable )
   nLen := LEN( &(cTable)->(FieldGet(FieldPos("SYNCF")) ) )
   FOR nPos:=1 TO nLen
        IF SUBSTR(&(cTable)->(SYNCF),  nPos , 1) <> SPACE(1) 
 El campo puede sincronizar
             IF .NOT. &(cSyncTabla)->(FieldGet(FieldPos( "SYNCD")) ) 
 no han sido sincronizados aun.
                  IF &(cSyncTabla)->(FieldGet(FieldPos( "TSYNC")) ) > 
&(cTable)->(TSYNC)   Datos que llegan son mas nuevos
                         FieldPut( nPos, 
&(cSyncTabla)->(FieldGet(FieldPos( nPos)) ) )                     produce 
la actualizacin del campo a sincronizar con la tabla.
                         &(cSyncTabla)->(FieldPut(FieldPos( "SYNCD")), .T. ) 
 Guardar estado de la sincronizacin.
                         &(cTable)->(FieldPut(FieldPos( "TSYNC")), TIME() ) 
 Guardar hora de sincronizacin.
                  ENDIF
             ENDIF
       ENDIF
  NEXT nPos

RETURN

1.4)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 Pre condicin:
 --------------
 cTable es ALIAS() de una tabla actualmente en uso.
 cSyncTable es el ALIAS() en uso de una tabla de sincronismo para cTable.

 Nota: Este cdigo no est libre de errores y no ha sido diseado con un 
propsito en especial
 ni para cumplir ciertos requerimientos especficos.
 Es un ejemplo sobre estrategias que pueden seguirse para sincronizar 
tablas.
 En este ejemplo se usa un archivo de texto.
PROCEDURE SyncTable( cTable,  cSyncTable)

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
LOCAL nLen := 0
LOCAL nPos := 0
LOCAL cMem := cTable + ".sync"
PRIVATE cSyncFields

  DBSelectArea( cTable )

   IF FILE( cMem )
       RESTORE FROM &(cMem) ADDITIVE
   ELSE
       cSyncFields := REPLICATE("X", FCOUNT() - 4)
   ENDIF

   nLen := LEN( cSyncFields )
   FOR nPos:=1 TO nLen
        IF SUBSTR(cSyncFields,  nPos , 1) <> SPACE(1) 
 El campo puede sincronizar
             IF .NOT. &(cSyncTabla)->(FieldGet(FieldPos( "SYNCD")) ) 
 no han sido sincronizados aun.
                  IF &(cSyncTabla)->(FieldGet(FieldPos( "TSYNC")) ) > 
&(cTable)->(TSYNC)   Datos que llegan son mas nuevos
                         FieldPut( nPos, 
&(cSyncTabla)->(FieldGet(FieldPos( nPos)) ) )                     produce 
la actualizacin del campo a sincronizar con la tabla.
                         &(cSyncTabla)->(FieldPut(FieldPos( "SYNCD")), .T. ) 
 Guardar estado de la sincronizacin.
                         &(cTable)->(FieldPut(FieldPos( "TSYNC")), TIME() ) 
 Guardar hora de sincronizacin.
                  ENDIF
             ENDIF
       ENDIF
  NEXT nPos

RETURN


1.5) La lista de campos a sincronizar puede almacenarse en un archivo de 
texto llamado mitabla.sync.
En ese caso, debe cambiarse el cdigo dentro del IF...ELSE....ENDIF.

   IF FILE( cMem )
       cSyncFields := SPACE( FCOUNT() - 4 )
       cFieldList :=  MEMOREAD(cMem)    lista de campos a sincronizar
       nLen := MLCOUNT( cFieldList, 80 )
       FOR i := 1 TO nLen
              nPos := &(cTable)->(FieldPos( MEMOLINE( cFieldList, 80, i) ) )
              cSyncFields := STUFF( cSyncFields, nPos, 1, "X" )
       NEXT i
   ELSE
       cSyncFields := REPLICATE("X", FCOUNT() - 4)    Todos los campos.
   ENDIF

Esto permite que haya sincronismo entre tablas que son creadas por cualquier 
aplicacin con la sola condicin de existir en el directorio apropiado.
Espero haber ayudado.

Por supuesto, se esperan crticas, comentarios, informe de errores, 
opiniones diferentes.

Saludos
Jos Luis Otermin
Soporte Tcnico
--------------------------------------------------------------------
Alaska Software Inc.
Foros de Usuarios: news://news.alaska-software.com
Foros de Usuarios Web: http://news.alaska-software.com
Pgina Web: http://www.alaska-software.com
Base de Conocimientos en la Web: http://www.alaska-software.com/kbase.shtm
Oficina en Europa: Fax: +49 (0) 61 96 - 77 99 99 23
Oficina en EEUU: Fax: +1 (646) 218 1281
-------------------------------------------------------

Estimado Jose

Bueno, el problema de los zip aun esta, pero he resulto mi problema de 
la siguiente forma.

Mi programa autonomo el cual corre 24/7 en un servidor, al momento de 
generar el archivo zip, genera un archivo xpf con unas variables donde 
indica las fechas de los archivos.
Dicho archivo se van dentro del zip y una vez en mis puntos de venta, 
cuando bajo ese archivo zip y lo descomprimo, tengo mi archivo xpf, el 
cual cargo en mi programa y logico reviso dichos valores de las variables.

De esa manera veo si mis tablas que actulize son lo mas recientes.

Lo de la sincronizacion tengo algo parecido en mi programa.
Ejemplo :

Cada punto de venta graba los datos de los clientes los cuales piden 
factura fiscal, en esa tabla grabo ademas de los datos del cliente, en 
que sucursal se dio de alta y la fecha y hora de modificacion.
Esta tabla de clientes se manda diariamente al servidor y ahi esta lo 
bueno...

En el servidor abro todas las tablas de los clientes de cada punto de 
venta e inicio las comparaciones entre mi tabla maestra de clientes, y 
grabo los nuevos clientes y modifico aquellos que fueron modificados 
segun la sucursal donde fue dado de alta y con sus fechas de 
actualiacion, una vez terminada dejo lista el maestro de clientes para 
que en la noche se empaque y se mande a los puntos de venta.

Bueno, eso es todo, muchas gracias por todo.

Osvaldo Ramirez







José Luis Otermin [Alaska Software] wrote:
> Hola Osvaldo,
> 
> He leido tu mensaje y creo que el problema reside en otro lugar.
> 
> En apariencia tu estrategia apunta a resolver una cuestión anterior que es 
> el sincronismo de tablas.
> Ese dilema es generalmente resuelto por medio de las siguientes estrategias:
> 
> 1.1) La presencia de la tabla a sincronizar en cierto directorio.
> 
> 1.2)
> Agregando los campos:
>              { "DSYNC", "D", 8, 0 },;    Fecha de modificación de dato a 
> sincronizar.
>              { "TSYNC", "C", 8, 0 },;    Hora de modificación de dato a 
> sincronizar.
>              { "SYNCD", "L", 1, 0 },;   ¿Está sincronizado? 
> (Predeterminado, .F.)
>              { "SYNCF", "C", fcount()-4, 0 };  un byte por campo a 
> sincronizar.
> Las dos tablas a sincronizar deben tener:
> 
> 
> 
> ¿Cómo se usa SYNCF?
> 
> Sea la tabla: (tomada de la documentación de Xbase++)
>       LOCAL aStructure := { ;
>               { "EMPLOYEENO"   , "C",  6, 0 }, ;    1
>               { "LASTNAME"     , "C", 20, 0 }, ;       2
>               { "FIRSTNAME"    , "C", 20, 0 }, ;       3
>               { "BIRTHDATE"    , "D",  8, 0 }, ;        4
>               { "GENDER"       , "L",  1, 0 }, ;           5
>               { "DEPARTMENT"   , "C", 20, 0 }, ;   6
>               { "INCOME"       , "N",  9, 2 }, ;         7
>               { "STREET"       , "C", 30, 0 }, ;          8
>               { "CITY"         , "C", 30, 0 }, ;             9
>               { "STATE"        , "C",  2, 0 }, ;            10
>               { "ZIP"          , "C",  5, 0 }, ;              11
>               { "TELEPHONE"    , "C", 15, 0 }, ;    12
>               { "MEMO"         , "M", 10, 0 },  ;   13
>              { "DSYNC", "D", 8, 0 },;    Fecha de modificación de dato a 
> sincronizar.
>              { "TSYNC", "C", 8, 0 },;    Hora de modificación de dato a 
> sincronizar.
>              { "SYNCD", "L", 1, 0 },;   ¿Está sincronizado? 
> (Predeterminado, .F.)
>              { "SYNCF", "C", 13, 0 };  un byte por campo a sincronizar.
>             }
> 
>       DbCreate( "EMPLOYEE", aStructure, "DBFNTX" )
> 
> Si deseamos sincronizar sólo INCOME, STREET, CITY, STATE, ZIP y MEMO,  el 
> campo SYNCF contendrá:
> SPACE(6)+"XXXXX"+SPACE(1)+"X"
> He escrito de esta forma para resaltar las seis primeras posiciones en 
> blanco que son campos que no se sincronizarán.
> Las  "X" se corresponden con cada campo a sincronizar.
> 
> En el caso del campo SYNCF simplemente se sincroniza el contenido del campo 
> si:
> 
> SUBSTR(mitabla->SYNCF, nPos, 1) == "X"  ( o cualquier otro símbolo 
> apropiado )
> 
> entonces FieldPut( nPos, (cSyncTabla)->(FieldGet(FieldPos( nPos)) ) ) 
> produce la actualización del campo a sincronizar con la tabla.
> 
> 1.3) Puede tenerse una variable guardada en disco cuyo nombre sea el mismo 
> de la tabla.
> En esa variable se tienen predeterminados los items a sincronizar.
> ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
>  Pre condición:
>  --------------
>  cTable es ALIAS() de una tabla actualmente en uso.
>  cSyncTable es el ALIAS() en uso de una tabla de sincronismo para cTable.
> 
>  Nota: Este código no está libre de errores y no ha sido diseñado con un 
> propósito en especial
>  ni para cumplir ciertos requerimientos específicos.
>  Es un ejemplo sobre estrategias que pueden seguirse para sincronizar 
> tablas.
>  En este ejemplo se usa un campo de la tabla como elemento de 
> sincronización.
> PROCEDURE SyncTable( cTable,  cSyncTable)
> 
> ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
> LOCAL nLen := 0
> LOCAL nPos := 0
> 
>   DBSelectArea( cTable )
>    nLen := LEN( &(cTable)->(FieldGet(FieldPos("SYNCF")) ) )
>    FOR nPos:=1 TO nLen
>         IF SUBSTR(&(cTable)->(SYNCF),  nPos , 1) <> SPACE(1) 
>  El campo puede sincronizar
>              IF .NOT. &(cSyncTabla)->(FieldGet(FieldPos( "SYNCD")) ) 
>  no han sido sincronizados aun.
>                   IF &(cSyncTabla)->(FieldGet(FieldPos( "TSYNC")) ) > 
> &(cTable)->(TSYNC)   Datos que llegan son mas nuevos
>                          FieldPut( nPos, 
> &(cSyncTabla)->(FieldGet(FieldPos( nPos)) ) )                     produce 
> la actualización del campo a sincronizar con la tabla.
>                          &(cSyncTabla)->(FieldPut(FieldPos( "SYNCD")), .T. ) 
>  Guardar estado de la sincronización.
>                          &(cTable)->(FieldPut(FieldPos( "TSYNC")), TIME() ) 
>  Guardar hora de sincronización.
>                   ENDIF
>              ENDIF
>        ENDIF
>   NEXT nPos
> 
> RETURN
> 
> 1.4)
> ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
>  Pre condición:
>  --------------
>  cTable es ALIAS() de una tabla actualmente en uso.
>  cSyncTable es el ALIAS() en uso de una tabla de sincronismo para cTable.
> 
>  Nota: Este código no está libre de errores y no ha sido diseñado con un 
> propósito en especial
>  ni para cumplir ciertos requerimientos específicos.
>  Es un ejemplo sobre estrategias que pueden seguirse para sincronizar 
> tablas.
>  En este ejemplo se usa un archivo de texto.
> PROCEDURE SyncTable( cTable,  cSyncTable)
> 
> ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
> LOCAL nLen := 0
> LOCAL nPos := 0
> LOCAL cMem := cTable + ".sync"
> PRIVATE cSyncFields
> 
>   DBSelectArea( cTable )
> 
>    IF FILE( cMem )
>        RESTORE FROM &(cMem) ADDITIVE
>    ELSE
>        cSyncFields := REPLICATE("X", FCOUNT() - 4)
>    ENDIF
> 
>    nLen := LEN( cSyncFields )
>    FOR nPos:=1 TO nLen
>         IF SUBSTR(cSyncFields,  nPos , 1) <> SPACE(1) 
>  El campo puede sincronizar
>              IF .NOT. &(cSyncTabla)->(FieldGet(FieldPos( "SYNCD")) ) 
>  no han sido sincronizados aun.
>                   IF &(cSyncTabla)->(FieldGet(FieldPos( "TSYNC")) ) > 
> &(cTable)->(TSYNC)   Datos que llegan son mas nuevos
>                          FieldPut( nPos, 
> &(cSyncTabla)->(FieldGet(FieldPos( nPos)) ) )                     produce 
> la actualización del campo a sincronizar con la tabla.
>                          &(cSyncTabla)->(FieldPut(FieldPos( "SYNCD")), .T. ) 
>  Guardar estado de la sincronización.
>                          &(cTable)->(FieldPut(FieldPos( "TSYNC")), TIME() ) 
>  Guardar hora de sincronización.
>                   ENDIF
>              ENDIF
>        ENDIF
>   NEXT nPos
> 
> RETURN
> 
> 
> 1.5) La lista de campos a sincronizar puede almacenarse en un archivo de 
> texto llamado mitabla.sync.
> En ese caso, debe cambiarse el código dentro del IF...ELSE....ENDIF.
> 
>    IF FILE( cMem )
>        cSyncFields := SPACE( FCOUNT() - 4 )
>        cFieldList :=  MEMOREAD(cMem)    lista de campos a sincronizar
>        nLen := MLCOUNT( cFieldList, 80 )
>        FOR i := 1 TO nLen
>               nPos := &(cTable)->(FieldPos( MEMOLINE( cFieldList, 80, i) ) )
>               cSyncFields := STUFF( cSyncFields, nPos, 1, "X" )
>        NEXT i
>    ELSE
>        cSyncFields := REPLICATE("X", FCOUNT() - 4)    Todos los campos.
>    ENDIF
> 
> Esto permite que haya sincronismo entre tablas que son creadas por cualquier 
> aplicación con la sola condición de existir en el directorio apropiado.
> Espero haber ayudado.
> 
> Por supuesto, se esperan críticas, comentarios, informe de errores, 
> opiniones diferentes.