FrameAppWS

<back to all web services

DefinicionProcedimientoRQ

Requires Authentication
The following routes are available for this service:
All Verbs/Utilidades/Procedimientos/Definicion
import 'package:servicestack/servicestack.dart';
import 'dart:typed_data';

// @DataContract
class IdentificadoresFunciones implements IConvertible
{
    // @DataMember
    String? AliasFuncion;

    // @DataMember
    String? NombreFuncion;

    // @DataMember
    String? Descripcion;

    // @DataMember
    String? TipoRespuesta;

    // @DataMember
    String? Background;

    // @DataMember
    String? UsuarioCreo;

    // @DataMember
    DateTime? FechaCreacion;

    // @DataMember
    int? Consecutivo;

    // @DataMember
    String? TipoExport;

    // @DataMember
    String? Ayuda;

    // @DataMember
    String? Endpoint;

    // @DataMember
    String? ConsumeAPI;

    // @DataMember
    String? APIRest;

    // @DataMember
    String? PropiedadRest;

    IdentificadoresFunciones({this.AliasFuncion,this.NombreFuncion,this.Descripcion,this.TipoRespuesta,this.Background,this.UsuarioCreo,this.FechaCreacion,this.Consecutivo,this.TipoExport,this.Ayuda,this.Endpoint,this.ConsumeAPI,this.APIRest,this.PropiedadRest});
    IdentificadoresFunciones.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        AliasFuncion = json['AliasFuncion'];
        NombreFuncion = json['NombreFuncion'];
        Descripcion = json['Descripcion'];
        TipoRespuesta = json['TipoRespuesta'];
        Background = json['Background'];
        UsuarioCreo = json['UsuarioCreo'];
        FechaCreacion = JsonConverters.fromJson(json['FechaCreacion'],'DateTime',context!);
        Consecutivo = json['Consecutivo'];
        TipoExport = json['TipoExport'];
        Ayuda = json['Ayuda'];
        Endpoint = json['Endpoint'];
        ConsumeAPI = json['ConsumeAPI'];
        APIRest = json['APIRest'];
        PropiedadRest = json['PropiedadRest'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'AliasFuncion': AliasFuncion,
        'NombreFuncion': NombreFuncion,
        'Descripcion': Descripcion,
        'TipoRespuesta': TipoRespuesta,
        'Background': Background,
        'UsuarioCreo': UsuarioCreo,
        'FechaCreacion': JsonConverters.toJson(FechaCreacion,'DateTime',context!),
        'Consecutivo': Consecutivo,
        'TipoExport': TipoExport,
        'Ayuda': Ayuda,
        'Endpoint': Endpoint,
        'ConsumeAPI': ConsumeAPI,
        'APIRest': APIRest,
        'PropiedadRest': PropiedadRest
    };

    getTypeName() => "IdentificadoresFunciones";
    TypeContext? context = _ctx;
}

class DefinicionParametro implements IConvertible
{
    String? Direccion;
    double? IdVista;
    String? TipoDato;
    String? NombreParametro;
    String? Alias;
    String? Ayuda;
    List<Map<String,dynamic>>? DatosLookup;
    String? CampoTexto;
    String? CampoValor;
    String? Version;
    bool? Obligatorio;
    String? ValorDefecto;
    bool? Visible;

    DefinicionParametro({this.Direccion,this.IdVista,this.TipoDato,this.NombreParametro,this.Alias,this.Ayuda,this.DatosLookup,this.CampoTexto,this.CampoValor,this.Version,this.Obligatorio,this.ValorDefecto,this.Visible});
    DefinicionParametro.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Direccion = json['Direccion'];
        IdVista = JsonConverters.toDouble(json['IdVista']);
        TipoDato = json['TipoDato'];
        NombreParametro = json['NombreParametro'];
        Alias = json['Alias'];
        Ayuda = json['Ayuda'];
        DatosLookup = JsonConverters.fromJson(json['DatosLookup'],'List<Map<String,dynamic>>',context!);
        CampoTexto = json['CampoTexto'];
        CampoValor = json['CampoValor'];
        Version = json['Version'];
        Obligatorio = json['Obligatorio'];
        ValorDefecto = json['ValorDefecto'];
        Visible = json['Visible'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Direccion': Direccion,
        'IdVista': IdVista,
        'TipoDato': TipoDato,
        'NombreParametro': NombreParametro,
        'Alias': Alias,
        'Ayuda': Ayuda,
        'DatosLookup': JsonConverters.toJson(DatosLookup,'List<Map<String,dynamic>>',context!),
        'CampoTexto': CampoTexto,
        'CampoValor': CampoValor,
        'Version': Version,
        'Obligatorio': Obligatorio,
        'ValorDefecto': ValorDefecto,
        'Visible': Visible
    };

    getTypeName() => "DefinicionParametro";
    TypeContext? context = _ctx;
}

// @DataContract
class PermisosFunciones implements IConvertible
{
    // @DataMember
    double? CodigoSistema;

    // @DataMember
    double? CodigoEmpresa;

    // @DataMember
    String? AliasFuncion;

    // @DataMember
    String? Usuario;

    // @DataMember
    String? UsuarioCreo;

    // @DataMember
    DateTime? FechaCreacion;

    // @DataMember
    String? IP;

    PermisosFunciones({this.CodigoSistema,this.CodigoEmpresa,this.AliasFuncion,this.Usuario,this.UsuarioCreo,this.FechaCreacion,this.IP});
    PermisosFunciones.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        CodigoSistema = JsonConverters.toDouble(json['CodigoSistema']);
        CodigoEmpresa = JsonConverters.toDouble(json['CodigoEmpresa']);
        AliasFuncion = json['AliasFuncion'];
        Usuario = json['Usuario'];
        UsuarioCreo = json['UsuarioCreo'];
        FechaCreacion = JsonConverters.fromJson(json['FechaCreacion'],'DateTime',context!);
        IP = json['IP'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'CodigoSistema': CodigoSistema,
        'CodigoEmpresa': CodigoEmpresa,
        'AliasFuncion': AliasFuncion,
        'Usuario': Usuario,
        'UsuarioCreo': UsuarioCreo,
        'FechaCreacion': JsonConverters.toJson(FechaCreacion,'DateTime',context!),
        'IP': IP
    };

    getTypeName() => "PermisosFunciones";
    TypeContext? context = _ctx;
}

class UltimoEstado implements IConvertible
{
    double? CodigoEjecucion;
    String? Estado;

    UltimoEstado({this.CodigoEjecucion,this.Estado});
    UltimoEstado.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        CodigoEjecucion = JsonConverters.toDouble(json['CodigoEjecucion']);
        Estado = json['Estado'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'CodigoEjecucion': CodigoEjecucion,
        'Estado': Estado
    };

    getTypeName() => "UltimoEstado";
    TypeContext? context = _ctx;
}

class DefinicionProcedimientoRS implements IConvertible
{
    IdentificadoresFunciones? Procedimiento;
    List<DefinicionParametro>? Parametros;
    List<PermisosFunciones>? Permisos;
    UltimoEstado? UltimoEstado;
    String? Error;

    DefinicionProcedimientoRS({this.Procedimiento,this.Parametros,this.Permisos,this.UltimoEstado,this.Error});
    DefinicionProcedimientoRS.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Procedimiento = JsonConverters.fromJson(json['Procedimiento'],'IdentificadoresFunciones',context!);
        Parametros = JsonConverters.fromJson(json['Parametros'],'List<DefinicionParametro>',context!);
        Permisos = JsonConverters.fromJson(json['Permisos'],'List<PermisosFunciones>',context!);
        UltimoEstado = JsonConverters.fromJson(json['UltimoEstado'],'UltimoEstado',context!);
        Error = json['Error'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Procedimiento': JsonConverters.toJson(Procedimiento,'IdentificadoresFunciones',context!),
        'Parametros': JsonConverters.toJson(Parametros,'List<DefinicionParametro>',context!),
        'Permisos': JsonConverters.toJson(Permisos,'List<PermisosFunciones>',context!),
        'UltimoEstado': JsonConverters.toJson(UltimoEstado,'UltimoEstado',context!),
        'Error': Error
    };

    getTypeName() => "DefinicionProcedimientoRS";
    TypeContext? context = _ctx;
}

class VersionLookup implements IConvertible
{
    double? CodLookup;
    String? Version;

    VersionLookup({this.CodLookup,this.Version});
    VersionLookup.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        CodLookup = JsonConverters.toDouble(json['CodLookup']);
        Version = json['Version'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'CodLookup': CodLookup,
        'Version': Version
    };

    getTypeName() => "VersionLookup";
    TypeContext? context = _ctx;
}

enum Lenguajes
{
    ES,
    PT,
    EN,
}

class DefinicionProcedimientoRQ implements IConvertible
{
    int? Consecutivo;
    List<VersionLookup>? VersionesLookupCliente;
    bool? DatosLookups;
    Lenguajes? Lenguaje;

    DefinicionProcedimientoRQ({this.Consecutivo,this.VersionesLookupCliente,this.DatosLookups,this.Lenguaje});
    DefinicionProcedimientoRQ.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Consecutivo = json['Consecutivo'];
        VersionesLookupCliente = JsonConverters.fromJson(json['VersionesLookupCliente'],'List<VersionLookup>',context!);
        DatosLookups = json['DatosLookups'];
        Lenguaje = JsonConverters.fromJson(json['Lenguaje'],'Lenguajes',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Consecutivo': Consecutivo,
        'VersionesLookupCliente': JsonConverters.toJson(VersionesLookupCliente,'List<VersionLookup>',context!),
        'DatosLookups': DatosLookups,
        'Lenguaje': JsonConverters.toJson(Lenguaje,'Lenguajes',context!)
    };

    getTypeName() => "DefinicionProcedimientoRQ";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'soluser_recaudo.sgsas.co', types: <String, TypeInfo> {
    'IdentificadoresFunciones': TypeInfo(TypeOf.Class, create:() => IdentificadoresFunciones()),
    'DefinicionParametro': TypeInfo(TypeOf.Class, create:() => DefinicionParametro()),
    'List<Map<String,dynamic>>': TypeInfo(TypeOf.Class, create:() => <Map<String,dynamic>>[]),
    'Map<String,dynamic>': TypeInfo(TypeOf.Class, create:() => Map<String,dynamic>()),
    'PermisosFunciones': TypeInfo(TypeOf.Class, create:() => PermisosFunciones()),
    'UltimoEstado': TypeInfo(TypeOf.Class, create:() => UltimoEstado()),
    'DefinicionProcedimientoRS': TypeInfo(TypeOf.Class, create:() => DefinicionProcedimientoRS()),
    'List<DefinicionParametro>': TypeInfo(TypeOf.Class, create:() => <DefinicionParametro>[]),
    'List<PermisosFunciones>': TypeInfo(TypeOf.Class, create:() => <PermisosFunciones>[]),
    'VersionLookup': TypeInfo(TypeOf.Class, create:() => VersionLookup()),
    'Lenguajes': TypeInfo(TypeOf.Enum, enumValues:Lenguajes.values),
    'DefinicionProcedimientoRQ': TypeInfo(TypeOf.Class, create:() => DefinicionProcedimientoRQ()),
    'List<VersionLookup>': TypeInfo(TypeOf.Class, create:() => <VersionLookup>[]),
});

Dart DefinicionProcedimientoRQ DTOs

To override the Content-type in your clients, use the HTTP Accept Header, append the .xml suffix or ?format=xml

HTTP + XML

The following are sample HTTP requests and responses. The placeholders shown need to be replaced with actual values.

POST /Utilidades/Procedimientos/Definicion HTTP/1.1 
Host: soluser-recaudo.sgsas.co 
Accept: application/xml
Content-Type: application/xml
Content-Length: length

<DefinicionProcedimientoRQ xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/Administrador.Modelo.Tipos">
  <Consecutivo>0</Consecutivo>
  <DatosLookups>false</DatosLookups>
  <Lenguaje>ES</Lenguaje>
  <VersionesLookupCliente>
    <VersionLookup>
      <CodLookup>0</CodLookup>
      <Version>String</Version>
    </VersionLookup>
  </VersionesLookupCliente>
</DefinicionProcedimientoRQ>

HTTP/1.1 200 OK
Content-Type: application/xml
Content-Length: length

<DefinicionProcedimientoRS xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/Administrador.Modelo.Tipos">
  <Error>String</Error>
  <Parametros>
    <DefinicionParametro>
      <Alias>String</Alias>
      <Ayuda>String</Ayuda>
      <CampoTexto>String</CampoTexto>
      <CampoValor>String</CampoValor>
      <DatosLookup xmlns:d4p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
        <d4p1:ArrayOfKeyValueOfstringanyType>
          <d4p1:KeyValueOfstringanyType>
            <d4p1:Key>String</d4p1:Key>
            <d4p1:Value />
          </d4p1:KeyValueOfstringanyType>
        </d4p1:ArrayOfKeyValueOfstringanyType>
      </DatosLookup>
      <Direccion>String</Direccion>
      <IdVista>0</IdVista>
      <NombreParametro>String</NombreParametro>
      <Obligatorio>false</Obligatorio>
      <TipoDato>String</TipoDato>
      <ValorDefecto>String</ValorDefecto>
      <Version>String</Version>
      <Visible>false</Visible>
    </DefinicionParametro>
  </Parametros>
  <Permisos xmlns:d2p1="http://schemas.datacontract.org/2004/07/Administrador.Modelo.Contexto">
    <d2p1:PermisosFunciones>
      <d2p1:AliasFuncion>String</d2p1:AliasFuncion>
      <d2p1:CodigoEmpresa>0</d2p1:CodigoEmpresa>
      <d2p1:CodigoSistema>0</d2p1:CodigoSistema>
      <d2p1:FechaCreacion>0001-01-01T00:00:00</d2p1:FechaCreacion>
      <d2p1:IP>String</d2p1:IP>
      <d2p1:Usuario>String</d2p1:Usuario>
      <d2p1:UsuarioCreo>String</d2p1:UsuarioCreo>
    </d2p1:PermisosFunciones>
  </Permisos>
  <Procedimiento xmlns:d2p1="http://schemas.datacontract.org/2004/07/Administrador.Modelo.Contexto">
    <d2p1:APIRest>String</d2p1:APIRest>
    <d2p1:AliasFuncion>String</d2p1:AliasFuncion>
    <d2p1:Ayuda>String</d2p1:Ayuda>
    <d2p1:Background>String</d2p1:Background>
    <d2p1:Consecutivo>0</d2p1:Consecutivo>
    <d2p1:ConsumeAPI>String</d2p1:ConsumeAPI>
    <d2p1:Descripcion>String</d2p1:Descripcion>
    <d2p1:Endpoint>String</d2p1:Endpoint>
    <d2p1:FechaCreacion>0001-01-01T00:00:00</d2p1:FechaCreacion>
    <d2p1:NombreFuncion>String</d2p1:NombreFuncion>
    <d2p1:PropiedadRest>String</d2p1:PropiedadRest>
    <d2p1:TipoExport>String</d2p1:TipoExport>
    <d2p1:TipoRespuesta>String</d2p1:TipoRespuesta>
    <d2p1:UsuarioCreo>String</d2p1:UsuarioCreo>
  </Procedimiento>
  <UltimoEstado>
    <CodigoEjecucion>0</CodigoEjecucion>
    <Estado>String</Estado>
  </UltimoEstado>
</DefinicionProcedimientoRS>