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: 'ws.jimsnwa.com', 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 .jsv suffix or ?format=jsv

HTTP + JSV

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: ws.jimsnwa.com 
Accept: text/jsv
Content-Type: text/jsv
Content-Length: length

{
	Consecutivo: 0,
	VersionesLookupCliente: 
	[
		{
			CodLookup: 0,
			Version: String
		}
	],
	DatosLookups: False,
	Lenguaje: ES
}

HTTP/1.1 200 OK
Content-Type: text/jsv
Content-Length: length

{
	Procedimiento: 
	{
		AliasFuncion: String,
		NombreFuncion: String,
		Descripcion: String,
		TipoRespuesta: String,
		Background: String,
		UsuarioCreo: String,
		FechaCreacion: 0001-01-01,
		Consecutivo: 0,
		TipoExport: String,
		Ayuda: String,
		Endpoint: String,
		ConsumeAPI: String,
		APIRest: String,
		PropiedadRest: String
	},
	Parametros: 
	[
		{
			Direccion: String,
			IdVista: 0,
			TipoDato: String,
			NombreParametro: String,
			Alias: String,
			Ayuda: String,
			DatosLookup: 
			[
				{
					String: {}
				}
			],
			CampoTexto: String,
			CampoValor: String,
			Version: String,
			Obligatorio: False,
			ValorDefecto: String,
			Visible: False
		}
	],
	Permisos: 
	[
		{
			CodigoSistema: 0,
			CodigoEmpresa: 0,
			AliasFuncion: String,
			Usuario: String,
			UsuarioCreo: String,
			FechaCreacion: 0001-01-01,
			IP: String
		}
	],
	UltimoEstado: 
	{
		CodigoEjecucion: 0,
		Estado: String
	},
	Error: String
}