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

COMPUTACIONENLINEA · « **en:** Jueves 24 de Enero de 2008, 14:00 »

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

Enko

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.

SoloCodigo

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

COMPUTACIONENLINEA

Re: Necesito Crear Rutina Para Modificar Archivo.dat

Enko

Re: Necesito Crear Rutina Para Modificar Archivo.dat