FiveTech Software tech support forums

ACC69 wrote:Hola buenos dias, antes que nada, les deseo Feliz Año nuevo 2016.

A todos ,es posible insertar una linea y registrar un nuevo registro dentro de un xBrowse ,en caso que al usuario retrocediera un registro anterior o en medio de los registros ya capturados ,por ejemplo:

1.- registro 1
2.- registro 2
3.- registro 3
"Insertando nuevo registro " al darle click o Insert
4.- registro 4
5.- registro 5

Pero que por ejemplo entre registro 3 y 4 se insertara un nuevo registro para el caso que el usuario se haya equivocado capturar algun dato!,esperando haberme explicado a lo que quiero hacer,quedo de ustedes, de algun ejemplo para mis necesidades.

Saludos y buen dia !

Atte: Adrian C. C.
acc69@hotmail.com

FranciscoA wrote:Hola Adrian. Talvez esto ayude en algo. Es para DBFs pequeñisimas.
http://fivetechsupport.com/forums/viewt ... ro#p127231

Tambien podrias pasar tu dbf a un array, hacer como te indica José Luis, y luego pasar de nuevo el array a dbf.
Saludos.

joseluisysturiz wrote:No se si estoy entendiendo bien, pero si el valor a INSERTAR se agregar manualmente, el TRI247, porque no solamente ordenar por ese campo y listo.? como dije antes, no se si estoy entendiendo bien lo que deseas hacer...dando una idea a lo que ya dijo Francisco...si usas un array para editar tus registros, como ya te comente, podrias agregar en registro nuevo en la posicion que quieras, y luego hacer un DELETE condicionado en la DBF y volcar los datos del ARRAY a la DBF, haciendo asi consecutivos los registros devueltos...comenta haber si es la idea correcta, saludos...

joseluisysturiz wrote:Cuando dije lo de ordenar seria por el campo con el numero de REFERENCIA, asi quedaria en su ordeny ser veria bien logica y esteticamente...Creo ya entender un poco mas lo que quieres, creo que con lo que te dije sobre ARRAY funcionaria, ya que puedes agregar registros en la posicion que quieras...no se si quiera si has intentado lo que te sugeri, aunque sea con un array sencillo y pequeño haber si cumple y llena tu requerimiento, otra opcion que se me vino al vuelo seria agregar un appen blank ya que usas DBF, mover(copiar), los registros una posicion hacia abajo y luego en el que quieres insertar el registro nuevo...luego de blanquearlo, usar replace por los datos nuevos entrados, no se si me entiendes o te confundo mas...saludos...

ACC69 wrote:

joseluisysturiz wrote:Cuando dije lo de ordenar seria por el campo con el numero de REFERENCIA, asi quedaria en su ordeny ser veria bien logica y esteticamente...Creo ya entender un poco mas lo que quieres, creo que con lo que te dije sobre ARRAY funcionaria, ya que puedes agregar registros en la posicion que quieras...no se si quiera si has intentado lo que te sugeri, aunque sea con un array sencillo y pequeño haber si cumple y llena tu requerimiento, otra opcion que se me vino al vuelo seria agregar un appen blank ya que usas DBF, mover(copiar), los registros una posicion hacia abajo y luego en el que quieres insertar el registro nuevo...luego de blanquearlo, usar replace por los datos nuevos entrados, no se si me entiendes o te confundo mas...saludos...

Gracias por tu atencion Ing. Luis, pero no quiero usar arreglos,me implica mover todo mi codigo ,alguna otra solucion ?? he visto en el foro hace años que es similiar lo que quiero hacer ,pero no lo encuentro en el foro,no recuerdo que año fue ,que igual compartio su codigo de como insertar un registro con su dialogo.

Saludos y buen dia !

Atte: Adrian C. C.
acc69@hotmail.com

Code: Select all  Expand view

//----------------------------------------------------------------------------//
//Duplica registro, similar a DupRecord() de FWH(dbtools), pero no desbloquea el registro añadido si no se lo indica en lUnLock
//lReleaseLocks indica si se debe liberar los bloqueos previos o no
FUNCTION DBDuplica( lReleaseLocks, lUnLock, lVerMsgError )
local aCpos := FieldsToArray( )

   DEFAULT lUnLock := .F.
   DEFAULT lVerMsgError := .F. //no se deberia mostra ningun mensaje en estas funciones, en forma similar a DBAppend()

   DBAppend(lReleaseLocks)
   if !NETERR()

      ArrayToFields(aCpos)

      if lUnLock
         DbCommit( )
         DbUnLock( )
      endif

      //return .T.   //01/02/13
      slNetOK := .T. //01/02/13

   else
      if lVerMsgError //no se deberia mostra ningun mensaje en estas funciones, en forma similar a DBAppend()
         MsgStop( "No se pudo duplicar el registro / Could not duplicate the record")
      endif
      slNetOK := .T. //01/02/13
   endif

   //RETURN .F.       //01/02/13
   RETURN ( slNetOK ) //01/02/13

//Funciones Para manejar la insercion de registros
//----------------------------------------------------------------------------//
function InsDupRecord(lRelease,lUnlock) // duplicates current record, debajo del actual

   local aRecord

   Default lUnlock TO .T.

   aRecord := FieldsToArray()

   If InsDownRecord(lRelease,.F.)
      //if NetRecLock(, RECNO() )
         ArrayToFields(aRecord)
     if lUnlock
            DBRUnLock( RECNO() )
         endif
      //else
         //MsgInfo( "El registro esta en uso, intente nuevamente", "InsDupRecord(..)" )
      //endif
   endif

return .T.

//----------------------------------------------------------------------------//
function InsDownRecord(lReleaseLocks,lUnlock) // Inserta un registro, debajo del actual

   local nRecord:=Recno()
   local aRecord
   local aRecordBlank

   Default lUnlock TO .T.

   //Verificamos que se pueda bloquear todos los registros a ser movidos
   DbSkip()
   DO WHILE !EOF()
      if ! NetRecLock(, RECNO() )
         MsgInfo( "Un Registro esta en uso, intente nuevamente", "InsDownRecord(..)" )
         return .F.
      endif
      DbSkip()
   ENDDO

   //Nos vamos al final de archivos
   DBGoBottom ()

   //copiamos el ultimo registro a un Array
   aRecord := FieldsToArray()

   //Añadimos un registro en blanco y guardamos sus valores (vacios) en una Array
   //APPEND BLANK
   if !NetAppend( ,lReleaseLocks)
      Return .F.
   endif
   aRecordBlank := FieldsToArray()

   ArrayToFields(aRecord)

   DbSkip(-1)

   DO WHILE Recno()<>nRecord
      DbSkip(-1)
      aRecord := FieldsToArray()
      DbSkip(1)
      DBRLock(Recno())
      ArrayToFields(aRecord)
      DbRUnLock(Recno())
      DbSkip(-1)
   ENDDO
   //DbUnLock()

   DbSkip(1)
   DBRLock(Recno())
   ArrayToFields(aRecordBlank)
   if lUnlock
      DbRUnLock(Recno())
   endif

return .T.
//----------------------------------------------------------------------------//
function InsUpRecord(lReleaseLocks,lUnlock) // Inserta un registro, arriba del actual

   local nRecord:=Recno()
   local aRecord
   local aRecordBlank

   Default lUnlock TO .T.

   //Verificamos que se pueda bloquear todos los registros a ser movidos
   DO WHILE !EOF()
      if ! NetRecLock(, RECNO() )
         MsgInfo( "Un Registro esta en uso, intente nuevamente", "InsUpRecord(..)" )
         return .F.
      endif
      DbSkip()
   ENDDO

   //Nos vamos al final de archivos
   DBGoBottom ()

   //copiamos el ultimo registro a un Array
   aRecord := FieldsToArray()

   //Añadimos un registro en blanco y guardamos sus valores (vacios) en una Array
   if !NetAppend(,lReleaseLocks)
      Return .F.
   endif
   aRecordBlank := FieldsToArray()

   ArrayToFields(aRecord)

   DbSkip(-1)

   DO WHILE Recno()<>nRecord
      DbSkip(-1)
      aRecord := FieldsToArray()
      DbSkip(1)
      DBRLock(Recno())
      ArrayToFields(aRecord)
      DbRUnLock(Recno())
      DbSkip(-1)
   ENDDO
   //DbUnLock()

   DBRLock(Recno())
   ArrayToFields(aRecordBlank)
   if lUnlock
      DbRUnLock(Recno())
   endif

return .T.
//----------------------------------------------------------------------------//
function SwapUpRecord()
   local aRecord,nRecord
   local aRecordUp,nRecordUp

   if NetRecLock(, nRecord:=RECNO() )

      aRecord := FieldsToArray()

      if DbSkipper(-1)=-1 .and. NetRecLock(, nRecordUp:=RECNO() )

         aRecordUp := FieldsToArray()
         ArrayToFields(aRecord)
     DBCommit()
         DbRUnlock(nRecordUp)

         DBGoto(nRecord)
         ArrayToFields(aRecordUp)
     DBCommit()
         DbRUnlock(nRecord)

      else
         return .F.
      endif
   else
      return .F.
   endif

return .T.
//----------------------------------------------------------------------------//
function SwapDownRecord()
   local aRecord,nRecord
   local aRecordDown,nRecordDown

   if NetRecLock(, nRecord:=RECNO() )

      aRecord := FieldsToArray()

      if DbSkipper(1)=1 .and. NetRecLock(, nRecordDown:=RECNO() )

         aRecordDown := FieldsToArray()
         ArrayToFields(aRecord)
     DBCommit()
         DbRUnlock(nRecordDown)

         DBGoto(nRecord)
         ArrayToFields(aRecordDown)
     DBCommit()
         DbRUnlock(nRecord)

      else
         return .F.
      endif
   else
      return .F.
   endif

return .T.

 

Code: Select all  Expand view

//Funciones Para manejar la insercion de registros
//----------------------------------------------------------------------------//
METHOD Duplica(lRelease,lUnlock) CLASS TDataADS

   local aRecord := AClone(::aBuffer)//FieldsToArray()

   Default lUnlock := .T.

   If ::Append(lRelease)
      ::aBuffer := aRecord //ArrayToFields(aRecord)
      ::Save()
      if lUnlock
         ::Commit()//::Save() no lo hace, porque el registro estaba bloqueado
         ::RecUnLock( ::RecNo() )//DBRUnLock(RECNO())
      endif
      return .T.
   endif

return .F.

//----------------------------------------------------------------------------//
METHOD DuplicaDwn(lReleaseLocks,lUnlock) CLASS TDataADS // duplicates current record, debajo del actual
   local aRecord := AClone(::aBuffer)//FieldsToArray()

   Default lUnlock := .T.

   If ::InsDownRecord(lReleaseLocks,.F.)
      ::aBuffer := aRecord //ArrayToFields(aRecord)
      ::Save()
      if lUnlock
         ::Commit()//::Save() no lo hace, porque el registro estaba bloqueado
         ::RecUnLock( ::RecNo() )//DBRUnLock(RECNO())
      endif
      return .T.
   endif

return .F.

//----------------------------------------------------------------------------//
METHOD InsDownRecord(lReleaseLocks,lUnlock) CLASS TDataADS // Inserta un registro, debajo del actual (NO se deberia tener ordenes activos)
   local nRecord:=::Recno()
   local aRecord
   //local aRecordBlank

   Default lUnlock := .T.

   //Verificamos que se pueda bloquear todos los registros a ser movidos
   ::Skip()
   DO WHILE !::EOF()
      if ! ::RecLock( ::RecNo() )//bloqueamos todos los registros//NetRecLock(, RECNO() )
         MsgInfo( "Un Registro esta en uso, intente nuevamente", "InsDownRecord(..)" )
         return .F.
      endif
      ::Skip()
   ENDDO

   //Vamos al final de la tabla (estamos en Eof())
   ::GoBottom()//Skip(-1)

   //copiamos el ultimo registro a un Array
   aRecord := AClone(::aBuffer)//FieldsToArray()

   //Añadimos un registro en blanco y guardamos sus valores (vacios) en una Array
   if !::Append()//estamos al final de la tabla//!NetAppend( ,lReleaseLocks)
      Return .F.
   endif
   //aRecordBlank := AClone(::aBuffer)//FieldsToArray()

   ::aBuffer := aRecord //ArrayToFields(aRecord)
   ::Save()

   ::Skip(-1)
   DO WHILE ::Recno()<>nRecord
      ::Skip(-1)
      aRecord := AClone(::aBuffer)//FieldsToArray()
      ::Skip(1)
      ::RecLock( ::RecNo() )//ya esta bloqueado//RLock()
      ::aBuffer := aRecord //ArrayToFields(aRecord)
      ::Save()
      ::RecUnLock( ::RecNo() )
      ::Skip(-1)
   ENDDO

   ::Skip()
   ::RecLock( ::RecNo() )//RLock()
   ::Blank()//::aBuffer := aRecordBlank //ArrayToFields(aRecordBlank)
   ::Save()
   if lUnlock
      ::Commit()//::Save() no lo hace, porque el registro estaba bloqueado
      ::RecUnLock( ::RecNo() )
   endif

   //::UnLock()//DbUnLock()

return .T.

//----------------------------------------------------------------------------//
METHOD InsUpRecord(lReleaseLocks,lUnlock) CLASS TDataADS // Inserta un registro, arriba del actual
   local nRecord:=::Recno()
   local aRecord
   //local aRecordBlank

   Default lUnlock := .T.

   //Verificamos que se pueda bloquear todos los registros a ser movidos
   DO WHILE !::EOF()
      if ! ::RecLock( ::RecNo() )//bloqueamos todos los registros//NetRecLock(, RECNO() )
         MsgInfo( "Un Registro esta en uso, intente nuevamente", "InsUpRecord(..)" )
         return .F.
      endif
      ::Skip()
   ENDDO

   ////Nos vamos al final de archivos
   //DBGoBottom ()

   ////copiamos el ultimo registro a un Array
   //aRecord := AClone(::aBuffer)//FieldsToArray()

   //Añadimos un registro en blanco y guardamos sus valores (vacios) en una Array
   if !::Append()//estamos al final de la tabla//!NetAppend( ,lReleaseLocks)
      Return .F.
   endif
   //aRecordBlank := AClone(::aBuffer)//FieldsToArray()

   //ArrayToFields(aRecord)

   //DbSkip(-1)

   DO WHILE ::Recno()<>nRecord
      ::Skip(-1)
      aRecord := AClone(::aBuffer)//FieldsToArray()
      ::Skip(1)
      ::RecLock( ::RecNo() )//ya esta bloqueado//RLock()
      ::aBuffer := aRecord //ArrayToFields(aRecord)
      ::Save()
      ::RecUnLock( ::RecNo() )
      ::Skip(-1)
   ENDDO

   ::RecLock( ::RecNo() )//RLock()
   ::Blank()//::aBuffer := aRecordBlank //ArrayToFields(aRecordBlank)
   ::Save()
   if lUnlock
      ::Commit()//::Save() no lo hace, porque el registro estaba bloqueado
      ::RecUnLock( ::RecNo() )
   endif

   //::UnLock()//DbUnLock()

return .T.

//----------------------------------------------------------------------------//
METHOD SwapUpRecord() CLASS TDataADS
   local aRecord,nRecord
   local aRecordUp,nRecordUp

   if ::RecLock( nRecord:=::RecNo() )//NetRecLock(, nRecord:=RECNO() )

      aRecord := AClone(::aBuffer)//FieldsToArray()

      if ::DbSkipper(-1)=1 .and. ::RecLock( nRecordUp:=::RecNo() )//NetRecLock(, nRecordUp:=RECNO() )

         aRecordUp := AClone(::aBuffer)//FieldsToArray()

         ::aBuffer := aRecord //ArrayToFields(aRecord)
         ::Save()
         ::Commit()//::Save() no lo hace, porque el registro estaba bloqueado
         ::RecUnLock( nRecordUp )//DbRUnlock(nRecordUp)

         ::GoTo(nRecord)//DBGoto(nRecord)
         ::aBuffer := aRecordUp //ArrayToFields(aRecordUp)
         ::Save()
         ::Commit()//::Save() no lo hace, porque el registro estaba bloqueado
         ::RecUnLock( nRecord )//DbRUnlock(nRecord)

      else
         return .F.
      endif
   else
      return .F.
   endif
return .T.

//----------------------------------------------------------------------------//
METHOD SwapDownRecord() CLASS TDataADS
   local aRecord,nRecord
   local aRecordDown,nRecordDown

   if ::RecLock( nRecord:=::RecNo() )//NetRecLock(, nRecord:=RECNO() )

      aRecord := AClone(::aBuffer)//FieldsToArray()

      if ::DbSkipper()=1 .and. ::RecLock( nRecordDown:=::RecNo() )//NetRecLock(, nRecordDown:=RECNO() )

         aRecordDown := AClone(::aBuffer)//FieldsToArray()

         ::aBuffer := aRecord //ArrayToFields(aRecord)
         ::Save()
         ::Commit()//::Save() no lo hace, porque el registro estaba bloqueado
         ::RecUnLock( nRecordDown )//DbRUnlock(nRecordDown)

         ::GoTo(nRecord)//DBGoto(nRecord)
         ::aBuffer := aRecordDown //ArrayToFields(aRecordDown)
         ::Save()
         ::Commit()//::Save() no lo hace, porque el registro estaba bloqueado
         ::RecUnLock( nRecord )//DbRUnlock(nRecord)

      else
         return .F.
      endif
   else
      return .F.
   endif
return .T.
 

RSalazarU wrote:Adrian:

Yo tengo el siguiente codigo para lo que quieres (usadas con ALIAS):

FUNCTION DBDuplica( lReleaseLocks, lUnLock, lVerMsgError )
FUNCTION InsDupRecord(lRelease,lUnlock)
FUNCTION InsDownRecord(lReleaseLocks,lUnlock)
FUNCTION InsUpRecord(lReleaseLocks,lUnlock)
FUNCTION SwapUpRecord()
FUNCTION SwapDownRecord()

Code: Select all  Expand view

//----------------------------------------------------------------------------//
//Duplica registro, similar a DupRecord() de FWH(dbtools), pero no desbloquea el registro añadido si no se lo indica en lUnLock
//lReleaseLocks indica si se debe liberar los bloqueos previos o no
FUNCTION DBDuplica( lReleaseLocks, lUnLock, lVerMsgError )
local aCpos := FieldsToArray( )

   DEFAULT lUnLock := .F.
   DEFAULT lVerMsgError := .F. //no se deberia mostra ningun mensaje en estas funciones, en forma similar a DBAppend()

   DBAppend(lReleaseLocks)
   if !NETERR()

      ArrayToFields(aCpos)

      if lUnLock
         DbCommit( )
         DbUnLock( )
      endif

      //return .T.   //01/02/13
      slNetOK := .T. //01/02/13

   else
      if lVerMsgError //no se deberia mostra ningun mensaje en estas funciones, en forma similar a DBAppend()
         MsgStop( "No se pudo duplicar el registro / Could not duplicate the record")
      endif
      slNetOK := .T. //01/02/13
   endif

   //RETURN .F.       //01/02/13
   RETURN ( slNetOK ) //01/02/13

//Funciones Para manejar la insercion de registros
//----------------------------------------------------------------------------//
function InsDupRecord(lRelease,lUnlock) // duplicates current record, debajo del actual

   local aRecord

   Default lUnlock TO .T.

   aRecord := FieldsToArray()

   If InsDownRecord(lRelease,.F.)
      //if NetRecLock(, RECNO() )
         ArrayToFields(aRecord)
     if lUnlock
            DBRUnLock( RECNO() )
         endif
      //else
         //MsgInfo( "El registro esta en uso, intente nuevamente", "InsDupRecord(..)" )
      //endif
   endif

return .T.

//----------------------------------------------------------------------------//
function InsDownRecord(lReleaseLocks,lUnlock) // Inserta un registro, debajo del actual

   local nRecord:=Recno()
   local aRecord
   local aRecordBlank

   Default lUnlock TO .T.

   //Verificamos que se pueda bloquear todos los registros a ser movidos
   DbSkip()
   DO WHILE !EOF()
      if ! NetRecLock(, RECNO() )
         MsgInfo( "Un Registro esta en uso, intente nuevamente", "InsDownRecord(..)" )
         return .F.
      endif
      DbSkip()
   ENDDO

   //Nos vamos al final de archivos
   DBGoBottom ()

   //copiamos el ultimo registro a un Array
   aRecord := FieldsToArray()

   //Añadimos un registro en blanco y guardamos sus valores (vacios) en una Array
   //APPEND BLANK
   if !NetAppend( ,lReleaseLocks)
      Return .F.
   endif
   aRecordBlank := FieldsToArray()

   ArrayToFields(aRecord)

   DbSkip(-1)

   DO WHILE Recno()<>nRecord
      DbSkip(-1)
      aRecord := FieldsToArray()
      DbSkip(1)
      DBRLock(Recno())
      ArrayToFields(aRecord)
      DbRUnLock(Recno())
      DbSkip(-1)
   ENDDO
   //DbUnLock()

   DbSkip(1)
   DBRLock(Recno())
   ArrayToFields(aRecordBlank)
   if lUnlock
      DbRUnLock(Recno())
   endif

return .T.
//----------------------------------------------------------------------------//
function InsUpRecord(lReleaseLocks,lUnlock) // Inserta un registro, arriba del actual

   local nRecord:=Recno()
   local aRecord
   local aRecordBlank

   Default lUnlock TO .T.

   //Verificamos que se pueda bloquear todos los registros a ser movidos
   DO WHILE !EOF()
      if ! NetRecLock(, RECNO() )
         MsgInfo( "Un Registro esta en uso, intente nuevamente", "InsUpRecord(..)" )
         return .F.
      endif
      DbSkip()
   ENDDO

   //Nos vamos al final de archivos
   DBGoBottom ()

   //copiamos el ultimo registro a un Array
   aRecord := FieldsToArray()

   //Añadimos un registro en blanco y guardamos sus valores (vacios) en una Array
   if !NetAppend(,lReleaseLocks)
      Return .F.
   endif
   aRecordBlank := FieldsToArray()

   ArrayToFields(aRecord)

   DbSkip(-1)

   DO WHILE Recno()<>nRecord
      DbSkip(-1)
      aRecord := FieldsToArray()
      DbSkip(1)
      DBRLock(Recno())
      ArrayToFields(aRecord)
      DbRUnLock(Recno())
      DbSkip(-1)
   ENDDO
   //DbUnLock()

   DBRLock(Recno())
   ArrayToFields(aRecordBlank)
   if lUnlock
      DbRUnLock(Recno())
   endif

return .T.
//----------------------------------------------------------------------------//
function SwapUpRecord()
   local aRecord,nRecord
   local aRecordUp,nRecordUp

   if NetRecLock(, nRecord:=RECNO() )

      aRecord := FieldsToArray()

      if DbSkipper(-1)=-1 .and. NetRecLock(, nRecordUp:=RECNO() )

         aRecordUp := FieldsToArray()
         ArrayToFields(aRecord)
     DBCommit()
         DbRUnlock(nRecordUp)

         DBGoto(nRecord)
         ArrayToFields(aRecordUp)
     DBCommit()
         DbRUnlock(nRecord)

      else
         return .F.
      endif
   else
      return .F.
   endif

return .T.
//----------------------------------------------------------------------------//
function SwapDownRecord()
   local aRecord,nRecord
   local aRecordDown,nRecordDown

   if NetRecLock(, nRecord:=RECNO() )

      aRecord := FieldsToArray()

      if DbSkipper(1)=1 .and. NetRecLock(, nRecordDown:=RECNO() )

         aRecordDown := FieldsToArray()
         ArrayToFields(aRecord)
     DBCommit()
         DbRUnlock(nRecordDown)

         DBGoto(nRecord)
         ArrayToFields(aRecordDown)
     DBCommit()
         DbRUnlock(nRecord)

      else
         return .F.
      endif
   else
      return .F.
   endif

return .T.

 

Espero que te sirva

Atentamente,

Rolando.

ACC69 wrote:

RSalazarU wrote:Adrian:

Yo tengo el siguiente codigo para lo que quieres (usadas con ALIAS):

FUNCTION DBDuplica( lReleaseLocks, lUnLock, lVerMsgError )
FUNCTION InsDupRecord(lRelease,lUnlock)
FUNCTION InsDownRecord(lReleaseLocks,lUnlock)
FUNCTION InsUpRecord(lReleaseLocks,lUnlock)
FUNCTION SwapUpRecord()
FUNCTION SwapDownRecord()

Code: Select all  Expand view

//----------------------------------------------------------------------------//
//Duplica registro, similar a DupRecord() de FWH(dbtools), pero no desbloquea el registro añadido si no se lo indica en lUnLock
//lReleaseLocks indica si se debe liberar los bloqueos previos o no
FUNCTION DBDuplica( lReleaseLocks, lUnLock, lVerMsgError )
local aCpos := FieldsToArray( )

   DEFAULT lUnLock := .F.
   DEFAULT lVerMsgError := .F. //no se deberia mostra ningun mensaje en estas funciones, en forma similar a DBAppend()

   DBAppend(lReleaseLocks)
   if !NETERR()

      ArrayToFields(aCpos)

      if lUnLock
         DbCommit( )
         DbUnLock( )
      endif

      //return .T.   //01/02/13
      slNetOK := .T. //01/02/13

   else
      if lVerMsgError //no se deberia mostra ningun mensaje en estas funciones, en forma similar a DBAppend()
         MsgStop( "No se pudo duplicar el registro / Could not duplicate the record")
      endif
      slNetOK := .T. //01/02/13
   endif

   //RETURN .F.       //01/02/13
   RETURN ( slNetOK ) //01/02/13

//Funciones Para manejar la insercion de registros
//----------------------------------------------------------------------------//
function InsDupRecord(lRelease,lUnlock) // duplicates current record, debajo del actual

   local aRecord

   Default lUnlock TO .T.

   aRecord := FieldsToArray()

   If InsDownRecord(lRelease,.F.)
      //if NetRecLock(, RECNO() )
         ArrayToFields(aRecord)
     if lUnlock
            DBRUnLock( RECNO() )
         endif
      //else
         //MsgInfo( "El registro esta en uso, intente nuevamente", "InsDupRecord(..)" )
      //endif
   endif

return .T.

//----------------------------------------------------------------------------//
function InsDownRecord(lReleaseLocks,lUnlock) // Inserta un registro, debajo del actual

   local nRecord:=Recno()
   local aRecord
   local aRecordBlank

   Default lUnlock TO .T.

   //Verificamos que se pueda bloquear todos los registros a ser movidos
   DbSkip()
   DO WHILE !EOF()
      if ! NetRecLock(, RECNO() )
         MsgInfo( "Un Registro esta en uso, intente nuevamente", "InsDownRecord(..)" )
         return .F.
      endif
      DbSkip()
   ENDDO

   //Nos vamos al final de archivos
   DBGoBottom ()

   //copiamos el ultimo registro a un Array
   aRecord := FieldsToArray()

   //Añadimos un registro en blanco y guardamos sus valores (vacios) en una Array
   //APPEND BLANK
   if !NetAppend( ,lReleaseLocks)
      Return .F.
   endif
   aRecordBlank := FieldsToArray()

   ArrayToFields(aRecord)

   DbSkip(-1)

   DO WHILE Recno()<>nRecord
      DbSkip(-1)
      aRecord := FieldsToArray()
      DbSkip(1)
      DBRLock(Recno())
      ArrayToFields(aRecord)
      DbRUnLock(Recno())
      DbSkip(-1)
   ENDDO
   //DbUnLock()

   DbSkip(1)
   DBRLock(Recno())
   ArrayToFields(aRecordBlank)
   if lUnlock
      DbRUnLock(Recno())
   endif

return .T.
//----------------------------------------------------------------------------//
function InsUpRecord(lReleaseLocks,lUnlock) // Inserta un registro, arriba del actual

   local nRecord:=Recno()
   local aRecord
   local aRecordBlank

   Default lUnlock TO .T.

   //Verificamos que se pueda bloquear todos los registros a ser movidos
   DO WHILE !EOF()
      if ! NetRecLock(, RECNO() )
         MsgInfo( "Un Registro esta en uso, intente nuevamente", "InsUpRecord(..)" )
         return .F.
      endif
      DbSkip()
   ENDDO

   //Nos vamos al final de archivos
   DBGoBottom ()

   //copiamos el ultimo registro a un Array
   aRecord := FieldsToArray()

   //Añadimos un registro en blanco y guardamos sus valores (vacios) en una Array
   if !NetAppend(,lReleaseLocks)
      Return .F.
   endif
   aRecordBlank := FieldsToArray()

   ArrayToFields(aRecord)

   DbSkip(-1)

   DO WHILE Recno()<>nRecord
      DbSkip(-1)
      aRecord := FieldsToArray()
      DbSkip(1)
      DBRLock(Recno())
      ArrayToFields(aRecord)
      DbRUnLock(Recno())
      DbSkip(-1)
   ENDDO
   //DbUnLock()

   DBRLock(Recno())
   ArrayToFields(aRecordBlank)
   if lUnlock
      DbRUnLock(Recno())
   endif

return .T.
//----------------------------------------------------------------------------//
function SwapUpRecord()
   local aRecord,nRecord
   local aRecordUp,nRecordUp

   if NetRecLock(, nRecord:=RECNO() )

      aRecord := FieldsToArray()

      if DbSkipper(-1)=-1 .and. NetRecLock(, nRecordUp:=RECNO() )

         aRecordUp := FieldsToArray()
         ArrayToFields(aRecord)
     DBCommit()
         DbRUnlock(nRecordUp)

         DBGoto(nRecord)
         ArrayToFields(aRecordUp)
     DBCommit()
         DbRUnlock(nRecord)

      else
         return .F.
      endif
   else
      return .F.
   endif

return .T.
//----------------------------------------------------------------------------//
function SwapDownRecord()
   local aRecord,nRecord
   local aRecordDown,nRecordDown

   if NetRecLock(, nRecord:=RECNO() )

      aRecord := FieldsToArray()

      if DbSkipper(1)=1 .and. NetRecLock(, nRecordDown:=RECNO() )

         aRecordDown := FieldsToArray()
         ArrayToFields(aRecord)
     DBCommit()
         DbRUnlock(nRecordDown)

         DBGoto(nRecord)
         ArrayToFields(aRecordDown)
     DBCommit()
         DbRUnlock(nRecord)

      else
         return .F.
      endif
   else
      return .F.
   endif

return .T.

 

Espero que te sirva

Atentamente,

Rolando.

Hola buenas tardes a todos, estuve fuera un tiempo del foro,y no he revisado mis mensajes, aun apenas leo tu mensaje Ing. Rolando y disculpa por no responderle y gracias por compartir tu rutina,le eche vistazo rapido a tu rutina, pero no se me hace conocido unas funciones que veo en tu rutina, por ejemplo:

ArrayToFields()
FieldsToArray()
DbSkipper(1)
DbRUnlock(nRecord)
NetRecLock(, nRecordDown:=RECNO() )

Y tampoco he realizado alguna rutina por arrays que todos comentan que es mas facil insertar usando AINS(), que hacerlo directamente en dbf,cuando lo que quiero hacer es insertar un registro a mitad por ejemplo de una factura o captura de cuentas de contabilidad,volvere a retomar de nuevo esa rutina que me falta insertar registro.

Saludos y buen dia.!
Atte: Adrian C. C.
acc69@hotmail.com