• Martes 17 de Septiembre de 2019, 13:17

Autor Tema:  Re: Necesito Crear Rutina Para Modificar Archivo.dat  (Leído 1907 veces)

COMPUTACIONENLINEA

  • Nuevo Miembro
  • *
  • Mensajes: 1
    • Ver Perfil
Re: Necesito Crear Rutina Para Modificar Archivo.dat
« en: Jueves 24 de Enero de 2008, 14:00 »
0
TENGO UN PROBLEMA A RESOLVER, TENGO NOCIONES MUY BASICAS DE PASCAL Y QUIERO DEPURAR UNA BASE DE DATOS DEL PROGRAMA SAINT ESPECIFICAMENTE EL ARCHIVO "APROD.DAT" DONDE TENGO EL ARCHIVO

TIPOS.PAS  QUE ES UNA UNIDAD DE PASCAL
{$A-,B-,D+,E-,F+,G-,I+,L+,N-,O+,P+,Q-,R-,S+,T-,V-,X+,Y+}

Unit
     Tipos;

Interface

{$IFDEF VER55}
Type
      Real48   = Real;
      SmallInt = Integer;
{$ENDIF}

{$IFDEF VER70}
Type
      Real48   = Real;
      SmallInt = Integer;
{$ENDIF}

Const
     KN = 40;
     KF = 10;

     { Facturas }
     _FA = '0';  { Factura         }
     _DE = '1';  { Devolucion      }
     _NE = '2';  { Nota de entrega }
     _PE = '3';  { Pedido          }
     _FE = '4';  { Factura Espera  }
     _PR = '5';  { Presupuesto     }

     { Compras  }
     _CO = '6';  { Compra          }
     _DC = '7';  { Devolucion      }
     _NP = '8';  { Nota de entrega }
     _CE = '9';  { Compra Espera   }
     _OC = ':';  { Orden de compra }

     { Traslados,  Cargos,  descargos,  Ajustes, Conversion a unidades     }
     _OpT= ';';
     _OpC= '<';
     _OpD= '=';
     _OpA= '>';
     _OpU= '?';

     _CxC = 'A';
     _CxP = 'B';
     _Imp = 'C';
     _RTI = 'D';
     _ETQ = 'E';
     _Tes = 'F';
     _Chq = 'G';

     TTCosto : Byte = 2;

     { Partes del producto  APART.DAT }
     _PrdComp = '0'; { Producto compuesto }
     _PrdProv = '1'; { Proveedor          }
     _PrdUbic = '2'; { Deposito o bodega  }
     _PrdTabl = '3'; { Tabla de comision  }

     { Convenios    ACONV.DAT }
     _PrdConv = '0'; {Convenios}
     _PrdOfer = '1'; {Encabezado Oferta}
     _PrdIOfer= '2'; {Item oferta}

     { Seriales }
     _Serial = '.';
     _SeFact = '0';  { Factura }
     _SeDevo = '1';  { Devolucion de factura     }
     _SeNota = '2';  { Nota de entrega cliente   }
     _SeComp = '3';  { Compra                    }
     _SeNoPr = '4';  { Nota de entrega proveedor }
     _SeDeCo = '5';  { Devolucion de compra      }
     _SeDesc = '6';  { Descargo de inventario    }
     _SeCarg = '7';  { Cargo de inventario       }
     _SeTras = '8';  { Traslados de inventario   }
     _SeFaEs = '9';
     _SeCoEs = ':';

     MEst:Byte = 13; { Mes de Estadisticas       }
     NLD       = 10; { Lineas de descripcion     }
     LCant     =  9;

     ExtNormal = '.DAT';
     ExtFormato= '.TXT'; { Formatos }
     ExtMensaje= '.MSG'; { Ayudas }
     ExtReimpre= '.PRN'; { Reporte por pantalla   }
     ExtSystem = '.SIS';
     ExtConfig = '.CFG';
{
     --------------------------
     Archivos de datos
     --------------------------
}
     TYCFileName  = 'ATYCE';
     NormalTYC    = 'AHITC';
     MesAntTYC    = 'TC';
     TCHIFileName: String[8] = NormalTYC;
     ATCFileName = 'EXTYC'; { Temporal de inventario  }
     PTCFileName = 'PFTYC'; { Temporal de factura  }
     PCCFileName = 'PCTYC'; { Temporal de compras  }
     POIFileName = 'PITYC'; { Temporal de operaciones inventario }

     PTFileName   = 'APART';
     CVFileName   = 'ACONV';
     HIFileName   = 'AHIPI'; { Costos de productos importados }
     CFFileName   = 'ACONF'; { Configuracion. Secuencial      }
     USFileName   = 'AUSER'; { Usuarios del sistema           }
     RGFileName   = 'AREGE'; { Resumen gerencial              }
     RIFileName   = 'AREPO'; { Archivo de Reportes            }
     ESFileName   = 'AITES';
     NormalHisFac = 'AFACT';    { Historico de facturas               }
     NormalHisCom = 'ACOMP';    { Historico de compras                }
     NormalHisOpI = 'AOPEI';    { Historico de operaciones Inventario }
     NormalIHi    = 'AITHI';    { Items de Historico            }
     NormalSer    = 'ASERI';    { Seriales de productos         }
     NormalPlani  = 'APLAN';

     MesAntHisFac = 'FA'; { Historico de operaciones      }
     MesAntHisCom = 'CO'; { Historico de operaciones      }
     MesAntHisOpI = 'OP'; { Historico de operaciones      }
     MesAntIHi    = 'IH'; { Items de Historico            }
     MesAntSer    = 'SI'; { Seriales de productos         }
     MesAntPlani  = 'PL';
     MesAntPartInv= 'IA';

     {** Archivos de hist¢ricos *******}
     FAFileName: String[8] = NormalHisFac;
     CPFileName: String[8] = NormalHisCom;
     OPFileName: String[8] = NormalHisOpI;
     IMFileName: String[8] = NormalIHi;
     SIFileName: String[8] = NormalSer;
     PLFileName: String[8] = NormalPlani;
     PTAFileName:String[8] = '';
     (*****************************************************************)

     FvFileName = 'VEDIT';
     FvBFileName= 'BEDIT';

     { Archivos temporales }
     FactDif    = 'AFAC';
     FacTemp    = 'PFAC';
     TempSeri   = 'TSER';
     ComTemp    = 'PCOMP';
     OpITemp    = 'POPIN';
     GRFileName = 'GRAFI';
     RPFileName = 'REPOR';

     { Arhivos del sistema }
     FilePrint  = 'IMPRE';
     MeAFileName= 'MENUA';
     MeVFileName= 'MENUV';
     MeCFileName= 'MENUC';
     MeBFileName= 'MENUB';

     { Configuracion de ventas             }
     CFVentas    = 'CNFV';     { 'CONFV';                            }
     COFileName  = 'CFCO';     { 'CNFCO';                            }
     GVFileName  = 'GAVE';     { 'GAVET';                            }
     VIFileName  = 'VISO';     { 'VISOR';                            }

     EmpFileName = 'DEMPR';    { Datos de la empresa                 }
     EstFileName = 'Login';    { Indica si el sistema esta instalado }


     MAFileName  = 'MA';       { Mes Actual de trabajo               }
     MaBFileName = 'MAB';

     FMTFact     = 'FACTURA';
     FMTFactD    = 'FACTURAD';
     FMTFactEsp  = 'FACTURAE';
     FMTFactFin  = 'FACTURAF';
     FMTFactDFin = 'FACTURDF';
     FMTPtoVenta = 'FACTCAJA';
     FMTOtro     = 'FACTURAO';
     FMTPresup   = 'PROFORMA';
     FMTPresupD  = 'PROFORMD';
     FMTPresupf  = 'PROFORMF';
     FMTPresufd  = 'PROFORFD';

     { ------ CONSUMIDOR FINAL -------}
     FMTCFact    = 'CFACTURA';
     FMTCFactD   = 'CFACTDES';
     FMTCFactEsp = 'CFACTESP';
     FMTCFactFin = 'CFACTFIN';
     FMTCFactDFin= 'CFACTDFI';
     FMTCPtoVenta= 'CFACTCAJ';
     FMTCPresup  = 'CPROFORM';
     FMTCPresupD = 'CPROFDES';
     FMTCPresupf = 'CPROFFIN';
     FMTCPresufd = 'CPROFFID';
     { -------------------------------}

     FMTTraslado = 'TRASLADO';
     FMTDescargo = 'DESCARGO';
     FMTCargo    = 'CARGOS';
     FMTAjuste   = 'AJUSTE';
     FMTPedido   = 'PEDIDO';

     FMTDevol    = 'DEVOLUCI';
     FMTNotaE    = 'NOTAENTR';
     FMTCompra   = 'COMPRAS';
     FMTOrdenCom = 'ORDENCOM';
     FMTOrdenCD  = 'ORDENCOD';
     FMTNotaEC   = 'NECOMPRA';
     FMTDevComp  = 'DEVCOMPR';
     FMTNDebitoP = 'NOTADEPR';
     FMTNCreditoP= 'NOTACRPR';

Type
     Str255      = String[255];
     Str80       = String[ 80];
     Str60       = String[ 60];
     Str40       = String[ 40];
     Str25       = String[ 25];
     Str10       = String[ 10];
     Str8        = String[ 08];

     RegSystemLogin         = Record
                                Estacion:       Byte;
                                PathData,
                                PathSystem,
                                PathDupData:    String[60];
                                Dummy1,
                                Dummy2:         Byte;
                                FData:          String[8];
                                MesActual:      String[6];
                                PathContab:     String[60];  {!!jesus  datos contab}
                                Si_Integrado:   Boolean;     {!!jesus}
                                EMonitorea:     Boolean;
                                Nombre:         String[30];
                                Si_Conectado:   Boolean;     {!!Jesus 13/9/95}
                                PathTemp:       String[60];
{$IFDEF COLOMBIA}
                                PathFiscal:     String[60];
                                Dummy:          Array[1..100] Of Byte;
{$ELSE}
                                PathFiscal:     String[49];
{$ENDIF}
                              End;
Const
     KS        = 30;
     MxT       = 15;  { Longitud titulos }
     NNivel    =  4;
     MxDF      = 15;
{$IFDEF _LICORES_}
     NOpVenta  = 65;
{$ELSE}
     NOpVenta  = 64;
{$ENDIF}
{$IFDEF _LICORES_}
     NOpCompra = 65;
{$ELSE}
     NOpCompra = 64;
{$ENDIF}
     MaxField  = 20;
     Lenform   = 46;
     MaxStrGraf= 35;
     MaxN      = 10;
     LenS      = 60;
     CIMPT     = 'PITEM';

Type
     RegEmpresaSaint        = Record
                                Direc1,
                                Direc2,
                                Telef:      String[80];
                                RifD:       String[20];
                                TitleIVA:   String[15];
                                Moneda:     String[10];
                                FAmerican:  Boolean;
                                OTitTax:    String[10];
                                TitleTalla,
                                TitleColor: String[13];
                                Dummy:      Array[1..33] Of Byte;
                              End;
     RegNotas               = Array[1..MaxN] Of String[LenS];

     SetOfByte              = Set Of Byte;

     RegInformacionVar      = Record { info de las variables }
                                Nro:  Word;
                                Name: String[60];
                                Len:  SmallInt;
                              End;

     FieldReport            = Record
                                Title:   String[MxT];
                                Len,
                                Dc:      Byte;
                                Tipo,
                                Total:   Char;
                                Detalle: String[LenForm];
                                Desde,
                                Hasta:   String[KN];
                              End;

     RegReportArchivo  =  Record
                            Status:  LongInt;
                            Tipo:    Char;
                            CodeR:   String[40];
                            Titulos: Array[1..2] Of String[40];
                            TLetra:  Char;
                            NroF:    Byte;
                            TCampos: Array[1..MaxField] Of FieldReport;
                            NrCamp:  Word;
                          End;

     RegOpcionVenta        =  Record
                                Activar:  Byte;
                                Nivel:    Array[1..NNivel] Of Boolean;
                                Default:  Record
                                            Mask: Word;
                                            Case byte Of
                                             0: (S: String[MxDF]);
                                             1: (R: Real48);
                                             2: (B: SmallInt);
                                          End;
                              End;

     RegFormatoVenta      = Array[1..NOpVenta] Of RegOpcionVenta;

     RegUsuario           = Record
                              Descripcion: String[30];
                              NivelU,
                              Modify,
                              Modify2:     Byte;
                              PassW:       String[10];
                              Cripto:      LongInt;
                              UMonitorea:  Boolean; {@@}
                              ModifB:      Byte;
                              ModifCXC,
                              ModifCXP:    Byte;
                              VerAlerta:   Boolean;
                              Dummy:       Array[1..45] Of Byte;
                            End;

     RegConfComentarios   = Array[1..MaxN] Of
                             Record
                               Titulos: String[15];
                               Activo,
                               Need:    Boolean;
                               Len:     SmallInt;
                             End;

     RegConfGaveta        =  Record
                               EsLpt:        Boolean;
                               Puerto,
                               Protocolo:    Byte;
                               DirPuerto:    String[10];
                               BitsApertura,
                               BitsCerrar:   String[80];
                               SoloDir:      Boolean;
                               Dummy:        Array[1..49] of Byte;
                             End;

     RegConfVisor         =  Record
                               Puerto,
                               Protocolo:    Byte;
                               NroLineas,
                               NroColumnas:  SmallInt;
                               DirPuerto:    String[10];
                               BitsLimpiar,
                               BitsScroll:   String[80];
                               AutoScroll:   Boolean;
                               MessageW:      String[50];
                               VDelay:       SmallInt;
                               DelayW:       SmallInt;
                               Dummy:        Array[1..50] of Byte;
                             End;

Const
     KC = 15;      { Producto            }
     KR = 15;      { Referencia          }
     KL = 10;      { Cliente             }
     KP = 10;      { Proveedor           }
     KM = 10;      { Multiple            }
     KO = 10;      { Otros               }
     KT = 10;      { !!KL+KF!! Transacciones CxC/CxP: 10 KL o KP }

     FlagMask:   Array[1..NNivel] Of Byte = ($01,$02,$04,$08);
     _NulModify  = $00;
     { Modify --------  }
     _ModifyFile = $01;
     _ModifyCxC  = $02;
     _ModifyCxP  = $04;
     _ModifyP0   = $08;
     _ModifyPMin = $10;
     _ModifyServ = $20;
     _Factura0   = $40;
     _ModifyExist= $80;

     { ModifCXC --------  }
     _CxCFac   = $01;
     _CxCND    = $02;
     _CxCNC    = $04;
     _CxCAdel  = $08;
     _CxCPago  = $10;
     _CxCGiro  = $20;
     _CxCReimp = $40;

     { ModifCXP --------  }
     _CxPFac   = $01;
     _CxPND    = $02;
     _CxPNC    = $04;
     _CxPAdel  = $08;
     _CxPPago  = $10;
     _CxPGiro  = $20;
     _CxPReimp = $40;

     {Modify2 --------  }
     _LCredito   = $01;
     _FactPedido = $02;
     _PedidoCompr= $04;
     _ModifCosto = $08;
     _ModifFecha = $10; { fecha sistema }
     _NewProducto= $20; { nuevos productos }
     _ModCostoCom= $40; { Modificar costos y cantidad }
     _Devolucion = $80; { Modificar costos y cantidad }
     { StFormato -----  }
     _OpenCash   = $01;

     { BITVarios  Clientes}
     _GranCont   = $01;
     _HaveConv   = $02;

     {_Varios    ItemFaturas }
     _MesAnt     = $01;
     _IsTalla    = $02;
     _IsColor    = $03;

     { Archivo Multiple  }
     _DigOtro  = '/';
     _DigVend   = '0';
     _DigMeca   = '1';
     _DigServ   = '2';
     _DigTarj   = '3';
     _DigZona   = '4';
     _DigDepa   = '5';
     _DigDepo   = '6';
     _DigOper   = '7';
{$IFDEF _TALLAS_}
     _DigTalla = '8';
     _DigColor = '9';
     MaxMulti  = _DigColor;
{$ELSE}
     MaxMulti   = _DigOper;
{$ENDIF}
     NoPermiteCredito = $01;
     NoPermiteDiasC   = $02;
     NoPermiteDiasT   = $04;

     MaxF  =  40; { Maximo de campos }
     _Alpha = 'A';
     _Number= 'N';
     _Date  = 'F';
     NPVP  =   3;
     NCOS  =   3;
     EstP  =  12; { 11 iva }
     EstC  =  14; { 13 iva }
     EstI  =  12;
     EstM  =   9;
     NMes  =  13;
     NV    =   5; { Tablas de comisiones }
     NTab  =   6; { Maximo 7: Tablas de cantidades }
     MxV   = 100; { Maximo de variables   }
     MaxTJT=   5; { Numero    "    " Tarjetas de credito  }

     FMTRecibo   = 'RECIBO';
     FMTNCredito = 'NOTACRED';
     FMTNDebito  = 'NOTADEBI';
     FMTGiro     = 'GIROS';
     FMTImpuesto = 'IMPUESTO';
     FMTRetenIVA = 'RETENIVA';

     GBFileName = 'AVARI';
     KPFileName = 'APROV'; { Proveedores }
     KLFileName = 'ACLIE'; { Clientes    }
     KCFileName = 'APROD'; { Productos   }
     KMFileName = 'AMULT'; { Multiple    }
     LOFileName = 'APROD'; { Productos   }

     SHFileName = 'AHISE'; { Historico de seriales         }
     VMFileName = 'AVMES'; { Ventas del mes            }
     CMFileName = 'ACMES'; { Compras del mes           }
     NormalCxC  = 'ACXCC'; { Cuentas por cobrar            }
     NormalCxP  = 'ACXPP'; { Cuentas por Pagar             }
     NormalReimp= 'AREIM'; { Reimpresi¢n cuentas por cobrar}
     KTFileName: String[8] = NormalCxC;
     TKFileName: String[8] = NormalCxP;
     IRFileName: String[8] = NormalReimp;
     MesAntCxC  = 'CC'; { Cuentas por cobrar            }
     MesAntCxP  = 'PP'; { Cuentas por Pagar             }
     MesAntReimp= 'RI';

     NVM = 14; {10 Original hasta 06-09-94 }
     NCM = 11; { 7   "        "       "    }

     { Acumula los diferentes IVAS  en facturacion }
Type
     ArrayComision          = Array[0..NPVP] Of Real48;
     ArrayPrecio            = Array[1..NPVP] Of Real48;
     ArrayCosto             = Array[1..NCOS] Of Real48;
     ArrayTabla             = Array[1..NTab] Of Record
                                                  Mto,
                                                  Porct: Real48;
                                                End;

     RegCampos              = Record
                                Name:   String[15];
                                TipoF:  Char;
                                Len,
                                Max,
                                Dec,
                                Need,
                                MaskI:  Byte;
                                InitB:  Word;
                                Activo,
                                InfoOn: Boolean;
                                Nivel:  Byte;
                                Dummy:  Array[1..2] Of Byte;
                              End;

     RegCamposVar           = Record
                                Name:   String[MxT];
                                TipoF:  Char;
                                Len,
                                Max,
                                Dec,
                                MaskI:  Byte;
                                Activo: Boolean;
                                Nivel:  Byte;
                                Dummy:  Array[1..10] Of Byte;
                              End;

     RegArchivo             = Array[1..MaxF] Of RegCampos;

     RegConfArchivo        =  Record
                                SizeRec,
                                NroField: Word;
                                MaxTl:    Byte;
                                Field:    RegArchivo;
                              End;

     RegUltimaOperacion     = Record
                                Fecha:  String[8];
                                Monto:  Real48;
                                Numero: String[KF];
                              End;

     ArrayTable             = Array[1..NV] Of Record
                                                 Mto,
                                                 Porct: Real48;
                                               End;
     ArraySplInv     = Array[1..1] Of Record
                                        Code: String[KM];
                                        InvI,
                                        UniI,
                                        Cant,
                                        CantU: Real48;
                                        Pues: String[10];
                                        RecInic:  LongInt;
                                      End;

     ArregloTarjetas        = Array[1..MaxTJT] Of Record
                                                    Nro: String[KM];
                                                    Mto: Real48;
                                                  End;
     RegGlobal              = Record
                                Status: LongInt;
                                Dummy:  Array[1..50] Of Byte;
                                Case Byte Of
                                 1:  (NroField,
                                      MaxTl:    Byte;
                                      Field:    Array[1..MxV] Of RegCamposVar);
                                 2:  (Valores:  Array[1..MxV] Of
                                                Record
                                                  Area: array[0..KN] Of Byte;
                                                End);
                              End;

{*-----------------------------------------------------------------*}
     RegSplProducto = Record
                        Case Byte Of
                         0: ( Conf:         RegConfArchivo);
                         1: ( Codigo:       String[KC];
                              Departa:      String[KM];
                              Descripcion:  Array[1..3] Of String[KN];
                              Refere:       String[KR];
                              Marca:        String[20];
                              Unidad:       String[3];
                              TipoP:        Char;
                              UsoI,
                              Serial,
                              ComiDept,
                              Compuesto:    Boolean;
                              IVAP:         Real48;
                              DiasE:        SmallInt;
                              Exento:       Boolean;
                              NeedBalanza:  Boolean;
                              UsaEmp:       Boolean;
                              EsPorcent:    Boolean;
                              ImpuestoI,
                              CantPedida,
                              CantCompro:   Real48;
                              CostoPrd:     ArrayCosto;
                              PVP:          ArrayPrecio;
                              FechaUC,
                              FechaUV:      String[8];
                              ExistMi,
                              ExistMa,
                              Existencia:   Real48;
                              Estadistics:  Array[1..NMes,1..EstI] Of Real48;
                              Empaque,
                              ExUnidades,
                              CostoUnidad,
                              PrecioUnidad: Real48;
                              OUnidad:      String[3];
                              FlagContab:   Boolean;
                              CtasContab:   Array[1..6] Of String[25];
                              TieneOferta,
                              TieneTalla,
                              TieneColor,
                              TieneLote:    Boolean;
                              Dummy2:       Array[1..72] Of Byte;
                              );
                      End;

     RegProducto    = Record
                        Status:   LongInt;
                        Special:  RegSplProducto;
                        DataArea: Array[1..1] Of Byte;
                      End;

     RegSplProveedor= Record
                        Case Byte Of
                         0: ( Conf:         RegConfArchivo);
                         1: ( Codigo:       String[KP];
                              Clase:        String[KO];
                              Descripcion,
                              Representante,
                              Direccion1,
                              Direccion2:   String[KN];
                              Telefonos:    String[30];
                              UltimaC,
                              UltimoP:      RegUltimaOperacion;
                              NDays:        SmallInt;
                              SaldoP,       {saldo pendiente}
                              PagosA,       {pagos anticipados}
                              MontoMax,     {}
                              IVAPagado,
                              PImpuesto:    Real48;
                              PromPay:      SmallInt;
                              Rif:          String[15];
                              TipoIva:      Char;
                              NIT:          String[15];
                              Dummy1:       Array[1..15] Of Byte;
                              Estadistics:  Array[1..NMes,1..EstP] Of Real48;
                              FlagContab:   Boolean;
                              CuentaContab: String[25];
                              eMail:        String[40];
                              Dummy2:       Array[1..9] Of Byte;
                              );
                      End;

     RegProveedor   = Record
                        Status:   LongInt;
                        Special:  RegSplProveedor;
                        DataArea: Array[1..1] Of Byte;
                      End;

     RegSplCliente  = Record
                        Case Byte Of
                         0: ( Conf:         RegConfArchivo);
                         1: ( Codigo:       String[KL];
                              Descripcion,
                              Representante,
                              Direccion1,
                              Direccion2:   String[40];
                              Telefonos:    String[30];
                              ZonaC,
                              VendC:        String[KM];
                              Clase:        String[KO];
                              MesVenc:      SmallInt;
                              TipoPVP:      Byte;
                              CreditoStat:  Byte;
                              MaxCredito,   {maximo credito permitido}
                              PagosA,       {pagos anticipados}
                              SaldoP,       {saldo pendiente}
                              MontoMax,     {Monto maximo venta}
                              MontoMaxCre,  {maximo credito}
                              IVARetenido:  Real48;
                              UltimaV,
                              UltimoP:      RegUltimaOperacion;
                              ChequesD:     Array[1..5] Of RegUltimaOperacion;
                              PromDay:      SmallInt;
                              NDays:        SmallInt;
                              RIF:          String[15];
                              TipoIva:      Char;
                              UVend:        String[KM]; {Ultimovendedor}
                              IntMora:      Boolean;
                              BitVarios:    Byte;
                              NIT:          String[15];
                              Estadistics:  Array[1..NMes,1..EstC] Of Real48;
                              FlagContab:   Boolean;
                              CuentaContab: String[25];
                              DescuentoC:   Real48;
                              eMail:        String[40];
                              Dummy2:       Array[1..9] Of Byte;
                              );
                      End;

     RegCliente     = Record
                        Status:   LongInt;
                        Special:  RegSplCliente;
                        DataArea: Array[1..1] Of Byte;
                      End;

     RegSplMultiple = Record
                        Codigo:      String[KM];
                        Descripcion: String[KN];
                        Clase:       String[KO];
                        Tipo:        Char;
                        Estadistics: Array[1..NMes,1..EstM] Of Real48;
                        Case Byte Of
                         0: ( DummyT:       SmallInt;
                              CNP,CTU,
                              CTV,CTC,
                              AVU,TDT,
                              TDM:          Char;
                              Dummy1:       Array[1..10] Of Byte;
                              PorcentPVP,
                              PorcentCOB:   ArrayComision;
                              PorcentajeU,
                              PorcentajeC,
                              PorcentajeV:  ArrayTable;
                              PorcentSPVP,
                              PorcentSCOB:  ArrayComision;
                              PorcentajeDT: ArrayTable);
                         1: ( SPorcentS,    { Dummy3 }
                              MontoS:       Real48;
                              SPorcentPVP:  ArrayComision;
                              SNP:          Char);
                         2: ( Descripcion2: Array[1..2] Of String[40];
                              Unidad:       String[10];
                              IVAP,
                              CostoB,
                              CostoPor,
                              PrecioV:      Real48;
                              UsaServidor:  Boolean;
                              FechaUV:      String[8];
                              PrecioO:      Array[1..2] Of Real48;
                              Exento:       Boolean;
                              TDummy:       Real48;
                              SComis:       String[15];
                              FlagContab1:   Boolean;
                              CuentaContab1,
                              CuentaContab2: String[25]);
                         3: ( PorcentajeT:  Real48;
                              PImpuesto:    ArrayTable;
                              Diferimiento: SmallInt;
                              BasePorct:    Real48 );
                         4: ( NroClts:      Word;      );
                         5: ( NPr:          SmallInt;
                              Compuesto,
                              Seriales:     Boolean;
                              Comi:         Char;
                              PorcentPVPD,
                              PorcentCOBD:  ArrayComision;
                              FlagContab2:  Boolean;
                              CtasContable: Array[1..6] Of String[25];
                              IsTalla,
                              IsColor:      Boolean;
                              IsLote:       Boolean);
                         6: ( TipoOp1:       Char;
                              DptoInicial:  String[KM]);
                       End;

     RegSplMultiple2 = Record
                         Case Byte Of
                          0: (Conf:  RegConfArchivo);
                          1: (MData: RegSplMultiple);
                       End;

     RegMultiple    =  Record
                         Status:    LongInt;
                         Spl:       RegSplMultiple2;
                         DataArea:  Array[1..1] Of Byte;
                       End;

     RegTransaccionCxC      = Record
                                Status:       LongInt;
                                Codigo:       String[KT];
                                IVAOrg:       Real48;
                                FromTran:     Boolean;
                                ComisionNC:   Boolean;
                                Station:      SmallInt;
                                TipoT:        String[2];
                                Numero:       String[KF];
                                Documento:    Array[1..2] Of String[KN];
                                FechaO,
            FechaE,
                                FechaV:       String[8];
                                MontoF,
                                CostoT,
                                Saldo,
                                Comision,
                                CHQ,
                                TJT,
                                EFE,
                                GIR,
                                ADEL:         Real48;
                                EsCHQ,
                                EsPago:       Boolean;
                                AfectaV:      Boolean;
                                DetalleCHQ:   String[40];
                                NoTjta:       ArregloTarjetas;
                                NroV,
                                NZona:        String[KM];
                                _xxxxxxx:     Byte;
                                HH,MM:        Word;
                                MontoOrg:     Real48;
                                EsRetencion:  Boolean;
                                MontoRetenc,
                                MontoIVA:     Real48;
                                LibroIVA:     Boolean;
                                CodeReten:    String[KM];
                                NCredito:     Boolean;
                                AfectaVta:    Boolean;
                                Reimprime:    Boolean;
                                Usuario:      Byte;
                                OpCode:       String[KM];
                                UltIntMora:   String[08];
                                PrxVisita:    String[08];
                                BaseReten:     Real48;
                                MultipleReten: Boolean;
                                BaseImponible: Real48;
                                MontoIAL:      Real48;
                                Dummy:        Array[1..13] Of Byte;
                              End;

     RegReimpresionCxC      = Record
                                IData:  RegTransaccionCxC;
                                Notas:  RegNotas;
                              End;

     RegTransaccionCxP      = Record
                                Status:      LongInt;
                                Codigo:      String[KT];
                                IVAOrg:      Real48;
                                FromTran:    Boolean;
                                Station:     SmallInt;
                                Dummy0:      Array[1..1] Of Byte;
                                TipoT:       String[2];
                                Numero:      String[KF];
                                Documento:   Array[1..2] Of String[KN];
                                FechaO,
            FechaE,
                                FechaV:      String[8];
                                MontoF,
                                Saldo,
                                CHQ,
                                TJT,
                                EFE,
                                GIR,
                                ADEL:        Real48;
                                EsPago:      Boolean;
                                DetalleCHQ:  String[40];
                                _xxxxxxx:    Byte;
                                HH,MM:       Word;
                                EsRetencion: Boolean;
                                MontoOrg,
                                MontoRetenc,
                                MontoIVA:    Real48;
            LibroIVA:    Boolean;
                                CodeReten:   String[KM];
                                NDebito:     Boolean;
                                AfectaC:     Boolean;
                                Usuario:     Byte;
                                OpCode:      String[KM];
                                BaseReten:   Real48;
                                MultipleReten: Boolean;
                                BaseImponible: Real48;
                                Dummy:       Array[1..37] Of Byte;
                              End;

     RegConfiguracion       = Record
                                MesesTran,
                                MesesOC,
                                MesesProf:        SmallInt;
                                CostosMes:        Real48;
                                PrxRecibo,
                                PrxNotaCredito,
                                PrxNotaDebito,
                                PrxFactura,
                                PrxNotaDebitoP,
                                PrxFacturaE,
                                PrxFacturaPV,
                                PrxProforma,
                                PrxDevolucion,
                                PrxNEntrega,
                                PrxTraslado,
                                PrxDescargo,
                                PrxOrdenC,
                                PrxCompraE,
                                PrxCargo,
                                PrxAjuste,
                                PrxPedido:        LongInt;
                                NumerarPedido:    Boolean;
                                MtoExtraGiro,
                                MtoIVAGeneral:    Real48;
                                RedondeaFinal:    Boolean;
                                ObligaSerial,
                                ObligaOperacion:  Boolean;
                                VersionSaint:     Word;
                                FleteIva,
                                FleteIVAC:        Boolean;
                                PrxImpuesto:      LongInt;
                                MesesSeriales:    SmallInt;
                                PagaRetencion,
                                IRedondear,
                                UsaIVA,
                                PVPConIVA:        Boolean;
                                CharFact:         Char;
                                RevSeptiembre:    Boolean;
                                AutoRetenedor:    Boolean;
                                PrxNotaCreditoP:  LongInt;
                                RevBaseI:         Boolean;
                                FactPPagina:      Boolean;
                                Dummy1:           Array[1..4] Of Byte;
                                PrxPlanilla:      LongInt;
                                VersionEmpaque:   Boolean;
                                PorctAutoReten:   Real48;
                                PrxRetencionIVA:  LongInt;
                                LongCorrel:       Byte;
                                Dummy2,
                                UsaAutoReten:     Boolean;
                                Dummy:            Array[1..88] Of Byte;
                              End;

     RegFacturaAcumulada   = Array[1..NMes,1..NVM] Of Real48; { Si se cambia
                                                              acuerdate del cierre }
     RegCompraAcumulada    = Array[1..NMes,1..NCM] Of Real48;
Type
     RegConvenioPrecios     = Record
                                Status: LongInt;
                                Tipo:   Char;
                                Case Byte Of
                                 0: ( PConvenio: Record
                                                   CodigoC:   String[KL];
                                                   ICodigo:   String[KC];
                                                   TipoC:     Char; { P=Precio / D=Descuento
                                                                    C=Cantidad  }
                                                   Name:      String[40];
                                                   NroL:      LongInt;
                                                   Cant1,
                                                   Cant2,
                                                   Monto,
                                                   Comision:  Real48;
                                                   IsPorC,
                                                   IsServ,
                                                   IsDepa:    Boolean;
                                                   Numero:    String[KF];
                                                   FechaI,
                                                   FechaF:    String[8];
                                                   Dummy:     Array[1..50] Of Byte;
                                                 End );
                                 1: ( PHeadOferta:  Record
                                                      Documento:   String[KF];
                                                      FechaIniH,
                                                      FechaFinH:   String[8];
                                                      Autorizado,
                                                      Responsable: String[KN];
                                                      TPV:         Array[1..NPVP] Of Char;
                                                      HI,HF,
                                                      MI,MF:       Word;
                                                    End);
                                 2: ( PItemOferta:  Record
                                                      CodigoIO:  String[KC];
                                                      Documento: String[KF];
                                                      Rango:     Byte;
                                                      FechaIniO,
                                                      FechaFinO: String[8];
                                                      Monto,
                                                      MontoU:    Real48;
                                                      TImpri:    Boolean;
                                                      HI,HF,
                                                      MI,MF:       Word;
                                                    End);
                                End;

     RegTallaYColor        =  Record
                                Status:  LongInt;
                                {-------------------}
                                CodigoP: String[KC];
                                CodeUbc,
                                CTalla,
                                CColor:  String[KM];
                                Existen: Real48;
                                OExiste: Real48;
                                Dummy:   Array[1..50] Of Byte;
                              End;

     RegTYCHistorico       =  Record
                                Status:     LongInt;
                                {-------------------}
                                Tipo:       Char;
                                NroFactura: String[KF];
                                NroL,
                                NroC:       Word;
                                CodigoP:    String[KC];
                                CodeUbc:    String[KM];
                                CTalla,
                                CColor:       String[KM];
                                Cantidad,
                                ACantidad:  Real48;
                                OCantidad:  Real48;
                                Dummy:      Array[1..50] Of Byte;
                              End;

     RegItemTYC  = Record
                     After,
                     Next:  LongInt;
                     Info:  RegTallaYColor;
                   End;

     RegItemTYCH = Record
                     After,
                     Next:  LongInt;
                     Info:  RegTYCHistorico;
                   End;

     RegComun    = Record
                     Case Byte Of
                      0: ( After,
                           Next:  LongInt);
                      1: ( RFirstDel,
                           RLastDel:  LongInt);
                   End;

     RegLotesProducto       = Record
                                Status:      LongInt;
                                Tipo:        Char;
                                Codigo:      String[KC];
                                NroLote:     String[KF];
                                Ubicado:     String[KM];
                                NroL:        Word;
                                Cant,
                                Costo,
                                Price,
                                POferta:     Real48;
                                FechaI,
                                FechaV,
                                FechaIOf,
                                FechaFOf:    String[08];
                                DescrOferta: String[KN];
                                Dummy:       Array[1..50] Of Byte;
                              End;

     RegAnexoProducto       = Record
                                Status: LongInt;
                                Codigo: String[KC];
                                Tipo:   Char;
                                NroL:   Word;
                                Name:   String[KN];
                                Case Byte Of
                                 0: ( PCompuesto: Record
                                                    CodigoP:  String[KC];
                                                    Serv,
                                                    UsaS,
                                                    IsSerial: Boolean;
                                                    Cant,
                                                    Cost:     Real48;
                                                    Precio:   ArrayPrecio;
                                                    EsUnidad: Boolean;
                                                    TUnidad:  String[3];
                                                  End );
                                 1: ( PProveedor: Record
                                                    CodeP:      String[KP];
                                                    Refer:      String[KR];
                                                    UCant,
                                                    UCosto:     Real48;
                                                    UFecha:     String[8];
                                                  End);
                                 2: ( PUbicacion: Record
                                                    Ubicado:    String[KM];
                                                    Existen,
                                                    InvInic,
                                                    UniInic:    Real48;
                                                    PuestoI:    String[10];
                                                    ExisUni:    Real48;
                                                    ExistMax:   Real48;
                                                    Dummy2:     Array[1..38] Of Byte;
                                                  End);
                                 3: ( TablaVenta: ArrayTabla);
                              End;

(*-----------------------------------------------------------------------*)
     RegItemRenglonFAC     =  Record
                                Descrip:     Array[1..NLD] Of String[KN];
                                Ref:         String[KR];
                                EsSerial,
                                EsCompuesto: Boolean;
                                FMCant:      String[LCant];
                                CantMayor:   Real48;
                                Exentuar:    Boolean;
                                ISigno:      ShortInt;
                                Unico:       Boolean;
                                Usuario:     Byte;
                                OTax:        Real48;
                                NU,
                                NServ:       String[KM];
                                _Varios:     Byte;
                                EsUnidad:    Boolean;
                                EsPorcentI:  Boolean;
                                Subtotal:    Boolean;
                                Serv,
                                FreeP,
                                UsaServ:     Boolean;
                                PV:          Byte;
                                IVAI,
                                Cost,
                                Desc,
                                PrecMinimo,
                                Exist,
                                Price,
                                Cant,
                                CantMayorAnt,
                                CantAnt:     Real48;
                                CompMenor:   Boolean;
                                Chkit:       Boolean;
                              End;

     RegItemRenglonCOM     =  Record
                                Descrip:     Array[1..NLD] Of String[KN];
                                Ref:         String[KR];
                                PAuto,
                                EsSerial:    Boolean;
                                FMCant:      String[LCant];
                                Exentuar:    Boolean;
                                Serv:        Boolean;
                                Usuario:     Byte;
                                MesAnt:      Boolean;
                                OTax:        Real48;
                                ChkIt:       Boolean;
                                EsPorcentI:  Boolean;
                                CostoU:      Real48;
                                Dummy1:      Array[0..3] of Byte;
                                NU:          String[KM];
                                UpdatePart,
                                IsPart,
                                FreeP:       Boolean;
                                IVAI,
                                CostoAx,
                                CostoI,
                                Desc,
                                Porct,
                                Exist,
                                Cant:        Real48;
                                Price:       ArrayPrecio;
                                CantAnt:     Real48;
                              End;

     RegItemRenglonINV     =  Record
                                Descrip:     Array[1..3] Of String[KN];
                                Ref:         String[KR];
                                FMCant:      String[LCant];
                                Exist2:      Real48;
                                EsSerial:    Boolean;
                                NU,
                                NU2:         String[KM];
                                Usuario:     Byte;
                                EsUnidad:    Boolean;
                                Costo,
                                Price,
                                Exist,
                                Cant:        Real48;
                                FreeP:       Boolean;
                                CantA:       Real48;
                                Puesto:      String[10];
                                Puesto2:     String[10];
                                CodeOp:      String[KM];
                                ExistU,
                                OUnidades,
                                NUnidades,
                                CostoUnid:   Real48;
                                ChkIt:       Boolean;
                                TUnidad:     String[3];
                                Dummy:       Array[0..1] Of Boolean;
                              End;

     RegItemOperacion      = Record
                               Status:      LongInt;
                               Tipo:        Char;
                               NroFactura:  String[KF];
                               CodigoI:     String[KC];
                               FechaI:      String[8];
                               NroL,
                               NroC:        Word;
                               Case Byte Of
                                0:  (ItemFactura:   RegItemRenglonFAC);
                                1:  (ItemCompra:    RegItemRenglonCOM);
                                2:  (ItemOperacion: RegItemRenglonINV);
                             End;

(*-- 3 Archivos: facturas, compras,  Operaciones Inventario ------------*)

     RegOperacionFAC       = Record
                               Status:    LongInt;
                               Tipo:      Char;
                               Numero:    String[KF];
                               FechaI,
                               FechaV:    String[8];
                               CodeCli:   String[KL];
                               DescripCl: String[40];
                               _xxxxxxx:   Byte;
                               HH,MM:     Word;
                               Notas:     RegNotas;
                               NVend,
                               NZona:     String[KM];
                               Monto,
                               IVA,
                               CostoF,
                               CancelE,
                               CancelT,
                               CancelC,
                               CancelA,
                               CancelG,
                               FleteF,
                               Descont1,      { Mto }
                               Descont2,
                               Impuesto,
                               CuotaExtra,
                               Interes1,      { % }
                               Interes2,      { % }
                               BsI1,
                               BsI2,
                               MtoFinanciar:  Real48;
                               DetalleCHQ:    String[40];
                               TotalVP,
                               TotalVS:       Real48;
                               OrdenC:        String[20];
                               NG,
                               NroM:          Word;
                               NoTjta:        ArregloTarjetas;
                               ComisionVDp,
                               ComisionCDp,
                               ComisionVta,
                               ComisionCob:   Real48;
                               {!! Nuevos campos  !!!}
                               TotalExento,
                               TotalGravable: Real48;
                               Usuario:       Byte;
                               Estado:        Char;
                               DpOrg:         String[KM];
                               DesctoP:       Real48;
                               TaxImpuesto:   Real48; { Licoreria }
                               RetencionIVA:  Real48;
                               FRIF:          String[15];
                               OpCode:        String[KM];
                               OrgFac:        String[KF];
                               Station:       SmallInt;
                               Dummy:         Array[1..37] Of Byte;
                             End;

     RegOperacionCOM       = Record
                               Status:     LongInt;
                               Tipo:       Char;
                               Numero:     String[KF];
                               FechaI,
                               FechaV:     String[8];
                               CodeCli:    String[KL];
                               DescripCl:  String[40];
                               _xxxxxxx:   Byte;
                               HH,MM:      Word;
                               Notas:      RegNotas;
                               Monto,
                               IVA,
                               CancelE,
                               CancelT,   {!!!}
                               CancelC,
                               CancelA,
                               CancelG,
                               FleteF,
                               Descont1,  { Mto }
                               Descont2,
                               DesctoP:       Real48;
                               DetalleCHQ:    String[40];
                               OrdenC:        String[20];
                               NG,
                               NroM:          Word;
                               Impuesto,
                               TotalExento,
                               TotalGravable: Real48;
                               Usuario:       Byte;
                               TaxImpuesto:   Real48;
                               RetencionIVA:  Real48;
                               DpOrg:         String[KM];
                               OpCode:        String[KM];
                               TotalVP,
                               TotalVS:       Real48;
                               Station:       SmallInt;
                               Dummy:         Array[1..2] Of Byte;
                             End;

     RegOperacionInv       = Record
                               Status:    LongInt;
                               Tipo:      Char;
                               Numero:    String[KF];
                               FechaI,
                               FechaV:    String[8];
                               CodeCli:   String[KL];
                               DescripCl: String[40];
                               _xxxxxxx:  Byte;
                               HH,MM:     Word;
                               Notas:     RegNotas;
                               Monto:     Real48;
                               DpOrigen,
                               DpDestino:     String[KN+KM];
                               UsoInterno:    Char;
                               UsoMaterial,
                               Responsable,
                               Autorizado:    String[40];
                               Usuario:       Byte;
                               OpCode:        String[KM];
                               Station:       SmallInt;
                               Dummy:         Array[1..48] Of Byte;
                             End;

(*-----------------------------------------------------------------------*)
     RegProductoImportado  = Record
                               Status:     LongInt;
                               CodigoP:    String[KC];
                               FechaC:     String[8];
                               Cantd:      Real48;
                               NroPlan:    String[30];
                               Provee:     String[KP+KN];
                               CostoProm:  Real48;
                               CostosP:    Array[1..2,1..12] Of Real48;
                               DolarPrice: ArrayPrecio;
                               Usuario:    Byte;
                               {!!! Nuevos campos }
                               Dummy2:     Array[1..49] Of Byte;
                             End;

     RegItemImportado = Record
                          Status:     LongInt;
                          Tipo:       Char;
                          NroFactura: String[KF];
                          NroL:       Word;
                          Case Byte Of
                           0:     ( CodigoP:    String[KC];
                                    NroPlan:    String[30];
                                    Valores:    Array[1..2,1..12] Of
                                                 Record
                                                   Mto,
                                                   Desc,
                                                   Porc: Real48;
                                                   StBs: String[15];
                                                 End;
                                    PromCosto:  Real48;
                                    PVPI:       ArrayPrecio;
                                    Dummy:      Array[1..50] Of Byte);
                        End;

     RegSerialProcesado    = Record
                               Status:     LongInt;
                               Tipo:       Char;
                               NroFactura: String[KF];
                               CodigoI:    String[KC];
                               NSerial:    String[KS];
                               CodeUbc:    String[KM];
                               NroLS,
                               NroLI:      Word;
                               Usuari
El mensaje contiene 1 archivo adjunto. Debes ingresar o registrarte para poder verlo y descargarlo.

Enko

  • Miembro de PLATA
  • *****
  • Mensajes: 1562
  • Nacionalidad: 00
    • Ver Perfil
Re: Necesito Crear Rutina Para Modificar Archivo.dat
« Respuesta #1 en: Jueves 24 de Enero de 2008, 20:15 »
0
las usuarios de este hilo:
http://foros.solocodigo.com/index.php?showtopic=33119
tuvieron problemas también con este sistema. Fijate si te sirve de ayuda.