TXMLDocument

[madmai]

Hola, A ver si alguien me puede poner algun ejemplo de como trabajar con este componente. Tengo un documento XML y no consigo modificar nada en ese documento, me gustaria poder añadir y modificar en ese doc xml, a ver si alguien me pone ejemplos de como hacerlo, gracias de antemano.

[[RONPABLO]]

Y porque no trabaja con el ClientDataSet, el permite cargar la información de un DataSet normal o de un archivo XML por medio del loadFromFile

[dec]

Hola,

Hace cierto tiempo escribí un componente al que dí el original e imaginativo nombre de "XmlComoIni"... creo que puede servirte para hacerte una idea, por lo menos, de ciertos aspectos del componente "TXmlDocument".

Código Delphi [-]
{ *********************************************************************** }
{                                                                         }
{ DecComp - Unos sencillos componentes                                    }
{                                                                         }
{ Copyright (c) 2005 dec - davidesperalta@gmail.com                       }
{ bajo la licencia GNU GPL >> ver en "licencia.txt"                       }
{                                                                         }
{ Créditos: A Lepe, del ClubDelphi.com ;-)                                }
{                                                                         }
{ *********************************************************************** }

unit UXmlComoIni;

interface

uses
  // Delphi 7
  //
  Classes, SysUtils, Graphics, XMLIntf, XMLDoc,

  // Pertenece al proyecto
  //
  UTypesDecComp;

type
  TXmlComoIni = class(TComponent)
  private
    FAcercade: TAcercade;
  published
    property Acercade: TAcercade read
      FAcercade write FAcercade stored false;
  private
    FFileName: TFileName;
    FDocXml: TXMLDocument;
    procedure CrearDocXml;
    procedure AbrirDocXml;
    procedure GuardarDocXml;
  public
    constructor Create(AOwner: TComponent); reintroduce; overload; override;
    constructor Create(AOwner: TComponent; const fileName: TFileName); reintroduce; overload;
    destructor Destroy; override;
    procedure UpdateFile;
    procedure DeleteKey(const seccion, clave: string);
    function SectionExists(const seccion: string) : boolean;
    function KeyExists(const seccion, clave: string) : boolean;
    procedure ReadSections(strings: TStrings);
    procedure DeleteSection(const seccion: string);
    procedure ReadSection(const seccion: string; strings: TStrings);
    procedure ReadSectionValues(const seccion: string; strings: TStrings);
    procedure WriteString(const seccion, clave, valor: string);
    function ReadString(const seccion, clave, defecto: string): string;
    procedure WriteInteger(const seccion, clave: string; const valor: integer);
    function ReadInteger(const seccion, clave: string; const defecto: integer) : integer;
    procedure WriteColor(const seccion, clave: string; const valor: TColor);
    function ReadColor(const seccion, clave: string; const defecto: TColor) : integer;
    procedure WriteBool(const seccion, clave: string; const valor: boolean);
    function ReadBool(const seccion, clave: string; const defecto: boolean) : boolean;
    procedure WriteDateTime(const seccion, clave: string; const valor: TDateTime);
    function ReadDateTime(const seccion, clave: string; const defecto: TDateTime) : TDateTime;
    procedure WriteFloat(const seccion, clave: string; valor: Double);
    function ReadFloat(const seccion, clave: string; const defecto: Double) : Double;
  end;

implementation

// Recursos/cadenas
//
{$I ..\inc\rsDecComp.inc}

{ TXmlComoIni }

// Constructor del componente.
//
constructor TXmlComoIni.Create(AOwner: TComponent);
begin
  inherited;
  FFileName := rsFileName;
  if not (csDesigning in ComponentState) then
  begin
    CrearDocXml;
    FFileName := ChangeFileExt(ParamStr(0), rsExtXml);
    AbrirDocXml;
  end;
end;

// Otro constructor del componente: en
// realidad desde el primero, como puede
// verse, llamamos a este otro.
//
constructor TXmlComoIni.Create(AOwner:
  TComponent; const fileName: TFileName);
begin
  CrearDocXml;
  if (fileName <> EmptyStr) then
    FFileName := fileName
  else
    FFileName := ChangeFileExt(ParamStr(0), rsExtXml);
  AbrirDocXml;
end;

// Destructor del componente.
//
destructor TXmlComoIni.Destroy;
begin
  if not (csDesigning in
    ComponentState) then
      GuardarDocXml;
  FDocXml.Free;
  inherited;
end;

// Crear el documento XML.
//
procedure TXmlComoIni.CrearDocXml;
begin
  FDocXml :=  TXMLDocument.Create(Self);
  FDocXml.Options := [doNodeAutoIndent];
end;

// Guardar el documento XML.
//
procedure TXmlComoIni.GuardarDocXml;
begin
  if FDocXml.Modified then
  begin
    FDocXml.SaveToFile(FFileName);
  end;
end;

// Actualizar el archivo XML.
//
procedure TXmlComoIni.UpdateFile;
begin
  GuardarDocXml;
end;

// Abrir el archivo XML.
//
procedure TXmlComoIni.AbrirDocXml;
begin
  if FileExists(FFileName) then
    FDocXml.LoadFromFile(FFileName)
  else
  begin
    FDocXml.Active := true;
    FDocXml.Version := '1.0';
    FDocXml.AddChild(rsRaizXml);
  end;
end;

// Leer el texto contenido en una determinada
// sección (nodo XML) dentro de una determinada
// clave (nodo XML).
//
function TXmlComoIni.ReadString(const
  seccion, clave, defecto: string): string;
var
  nodoClave,
  nodoSeccion: IXMLNode;
begin
  Result := defecto;
  with FDocXml.DocumentElement do
    nodoSeccion := ChildNodes.FindNode(seccion);
  if not Assigned(nodoSeccion) then
    Exit; // No existe la sección
  with nodoSeccion do
    nodoClave := ChildNodes.FindNode(clave);
  if not Assigned(nodoClave) then
    Exit; // No existe la clave
  Result := nodoClave.Text;
end;

// Escribir una cadena en una
// determinada sección y clave.
//
procedure TXmlComoIni.WriteString(const
  seccion, clave, valor: string);
var
  nodoClave,
  nodoSeccion: IXMLNode;
begin
  if ReadString(seccion, clave, EmptyStr) = valor then
    Exit; // El valor a escribir y el actual coinciden
  with FDocXml.DocumentElement do begin
    nodoSeccion := ChildNodes.FindNode(seccion);
    if not Assigned(nodoSeccion) then
      nodoSeccion := AddChild(seccion);
  end;
  with nodoSeccion do begin
    nodoClave := ChildNodes.FindNode(clave);
    if not Assigned(nodoClave) then
      nodoClave := AddChild(clave);
  end;
  nodoClave.Text := valor;
end;

// Leer una cadena del documento XML pero
// devolverla como una valor de tipo Integer.
//
function TXmlComoIni.ReadInteger(const seccion,
  clave: string; const defecto: integer): integer;
begin
  Result := StrToInt(ReadString(
    seccion, clave, IntToStr(defecto)));
end;

// Escribir una cadena en el documento XML
// obteniendo el valor de la misma de un Integer.
//
procedure TXmlComoIni.WriteInteger(const seccion,
  clave: string; const valor: integer);
begin
  WriteString(seccion, clave, IntToStr(valor));
end;

// Leer una cadena del documento XML pero
// devolverla como una valor de tipo TColor.
//
function TXmlComoIni.ReadColor(const seccion,
  clave: string; const defecto: TColor): integer;
begin
  Result := StringToColor(ReadString(
    seccion, clave, ColorToString(defecto)));
end;

// Escribir una cadena en el documento XML
// obteniendo el valor de la misma de un TColor.
//
procedure TXmlComoIni.WriteColor(const seccion,
  clave: string; const valor: TColor);
begin
  WriteString(seccion, clave, ColorToString(valor));
end;

// Leer una cadena del documento XML pero
// devolverla como una valor de tipo boolean.
//
function TXmlComoIni.ReadBool(const seccion,
  clave: string; const defecto: boolean): boolean;
begin
  Result := StrToBool(ReadString(
    seccion, clave, BoolToStr(defecto)));
end;

// Escribir una cadena en el documento XML
// obteniendo el valor de la misma de un boolean.
//
procedure TXmlComoIni.WriteBool(const seccion,
  clave: string; const valor: boolean);
begin
  WriteString(seccion, clave, BoolToStr(valor));
end;

// Leer una cadena del documento XML pero
// devolverla como una valor de tipo TDateTime.
//
function TXmlComoIni.ReadDateTime(const seccion,
  clave: string; const defecto: TDateTime): TDateTime;
begin
  Result := StrToDateTime(ReadString(
    seccion, clave, DateTimeToStr(defecto)));
end;

// Escribir una cadena en el documento XML
// obteniendo el valor de la misma de un TDateTime.
//
procedure TXmlComoIni.WriteDateTime(const seccion,
  clave: string; const valor: TDateTime);
begin
  WriteString(seccion, clave, DateTimeToStr(valor));
end;

// Leer una cadena del documento XML pero
// devolverla como una valor de tipo Double.
//
function TXmlComoIni.ReadFloat(const seccion,
  clave: string; const defecto: Double): Double;
begin
  Result := StrToFloat(ReadString(
    seccion, clave, FloatToStr(defecto)));
end;

// Escribir una cadena en el documento XML
// obteniendo el valor de la misma de un Double.
//
procedure TXmlComoIni.WriteFloat(const
  seccion, clave: string; valor: Double);
begin
  WriteString(seccion, clave, FloatToStr(valor));
end;

// Borrar una determinada clave (nodo XML).
//
procedure TXmlComoIni.DeleteKey(const
  seccion, clave: string);
var
  nodoClave,
  nodoSeccion: IXMLNode;
begin
  with FDocXml.DocumentElement do
    nodoSeccion := ChildNodes.FindNode(seccion);
  if Assigned(nodoSeccion) then
  begin
    nodoClave := nodoSeccion.ChildNodes.FindNode(clave);
    if Assigned(nodoClave) then
      nodoSeccion.ChildNodes.Delete(nodoClave.NodeName);
  end;
end;

// Comprobar la existencia de una
// determinda clave (nodo XML).
//
function TXmlComoIni.KeyExists(const
  seccion, clave: string) : boolean;
var
  nodoSeccion: IXMLNode;
begin
  with FDocXml.DocumentElement do
    nodoSeccion := ChildNodes.FindNode(seccion);
  if Assigned(nodoSeccion) then
  begin
    with nodoSeccion do
      Result := (ChildNodes.IndexOf(clave)<>-1);
  end
  else
    Result := false;
end;

// Comprobar la existencia de una
// determinada sección (nodo XML).
//
function TXmlComoIni.SectionExists(const
  seccion: string) : boolean;
var
  nodoSeccion: IXMLNode;
begin
  with FDocXml.DocumentElement do
    nodoSeccion := ChildNodes.FindNode(seccion);
  Result := Assigned(nodoSeccion);
end;

// Leer los valores (strings) de una determinada
// sección o, como queda dicho, nodo XML. ;-)
// 
procedure TXmlComoIni.ReadSectionValues(const
  seccion: string; strings: TStrings);
var
  i: integer;
  nodoClave,
  nodoSeccion: IXMLNode;
begin
  with FDocXml.DocumentElement do
    nodoSeccion := ChildNodes.FindNode(seccion);
  if Assigned(nodoSeccion) then
  begin
    strings.Clear;
    for i := 0 to nodoSeccion.ChildNodes.Count-1 do
    begin
      nodoClave := nodoSeccion.ChildNodes[i];
      if Assigned(nodoClave)  and
        (nodoClave.IsTextElement) then
          strings.Add(nodoClave.Text);
    end;
  end;
end;

// Leer los nombres de las diferentes secciones.
//
procedure TXmlComoIni.ReadSections(strings: TStrings);
var
  i: integer;
  nodoSeccion: IXMLNode;
begin
  nodoSeccion := FDocXml.DocumentElement;
  if Assigned(nodoSeccion) then
  begin
    strings.Clear;
    for i := 0 to nodoSeccion.ChildNodes.Count-1 do
      strings.Add(nodoSeccion.ChildNodes[i].NodeName);
  end;
end;

// Leer las claves de una determinada sección.
//
procedure TXmlComoIni.ReadSection(const
  seccion: string; strings: TStrings);
var
  i: integer;
  nodoClave,
  nodoSeccion: IXMLNode;
begin
  with FDocXml.DocumentElement do
    nodoSeccion := ChildNodes.FindNode(seccion);
  if Assigned(nodoSeccion) then
  begin
    strings.Clear;
    for i := 0 to nodoSeccion.ChildNodes.Count-1 do
    begin
      nodoClave := nodoSeccion.ChildNodes[i];
      strings.Add(nodoClave.NodeName);
    end;
  end;
end;

// Borrar una sección (nodo XML) completa.
//
procedure TXmlComoIni.DeleteSection(const seccion: string);
var
  nodoSeccion: IXMLNode;
begin
  nodoSeccion := FDocXml.DocumentElement.ChildNodes.FindNode(seccion);
  if Assigned(nodoSeccion) then
    FDocXml.DocumentElement.ChildNodes.Delete(nodoSeccion.NodeName);
end;

end.

[madmai]

Gracias pero prefiero trabajar con componentes de delphi, si alguien tiene ejemplos de como trabajar con TXMLDocument, se lo agradeceria si los colgase, gracias de antemano.

[dec]

Hola,

Esto... el código fuente que expongo más arriba trabaja con el componente de Delphi "TXMLDocument"... No he dicho que uses "mi componente", sino que te fijes en que ahí se implementan métodos que usan el componente "TXMLDocument" para escribir, leer, editar un archivo XML, etc.

Es decir, en mi opinión, me ha parecido que el componente que yo escribí (y que no dije que useses) trabaja con el componente que a ti te interesa. Lo puse por si podía servirte de algo, vamos.

[madmai]

Vale, no te entendí, lo mirare gracias

[Edgar Perez]

Hola Madmai...

Creo saber lo que ocupas, mira, Yo hice algo mas o menos como lo que necesitas y para ello eche mano del XMLMapper que viene con Delphi, ahi puedes generar el XMLDocument y dos transformaciones que son ToDp.xtr y ToXML.xtr. El archivo ToDp.xtr te sirve para convertir lo que esta en el XMLDocument a un DataPacket y el archivo ToXML.xtr hace lo contrario, convierte el DataPacket a un XML.

Aqui tienes algo sobre XML Mapper:

http://dn.codegear.com/article/28010


Una vez que generes estos 3 archivos: XMLDocument.XML, XMLDocumentToDp.xtr, XMLDocumentToXML.xtr, ahora en Delphi ocupas de los siguientes componentes:

XMLTransformProvider (En la paleta de DataAccess)
ClientDataSet (En la paleta DataAccess o tu preferido)

Ahora bien, primero tienes que configurar el XMLTransformProvider las siguientes propiedades en el inspector de objetos:

* Name = XMLDsp

* TransformRead.TransformationFile = Ruta completa de tu archivo XMLDocumentToDp.xtr

* TransformWrite.TransformationFile = Ruta completa de tu archivo XMLDocumentToXML.xtr

* XMLDataFile = Ruta compleata de tu archivo XMLDocument.XML


Una vez que ya tengas echo lo anterior, ahora en el Componente ClientDataSet solo tienes que ajustar la propiedad

ProviderName = XMLDsp

Espero te sirva....

Edgar Perez...

[galexanderch]

Yo tengo el XML generado, pero la aplicacion donde debo enviarlo requiere que se inserte este codigo:

<req:ShipmentValidateRequest xmlns:req="Enlace" xmlns:xsi="Enlace" xsi:schemaLocation="Enlace ship-val-req.xsd">

Cual es el codigo que debo usar?

Yo tengo actualmente esto:

Código Delphi [-]
procedure TFEnviar.BBEnviarClick(Sender: TObject);
var
Error : String;
FDocXml: TXMLDocument;
//SaveDialog1 : TSaveDialog;
nodoClave, nodoSeccion, nodoObjeto, nodoRegla, nodoRegla2: IXMLNode;
I : Integer;
Parser : String;
begin
If MessageDlg('Está seguro de aceptar la Transaccion?',Mtconfirmation,[MbNo,MbYes],0) = MrYes then
begin
 
Try
FDocXml := TXMLDocument.Create(Self);
FDocXml.Options := [doNodeAutoIndent];
FDocXml.Active:=true;
FDocXml.Version := '1.0';

No se si crear un Nodo, o invocar a una metodo para incluir eso en el Parser del TXMLDocument?