Subdirección de las Tecnologías de la Información y Comunicaciones

Área de Gobernanza y Calidad

Cumplimiento normativo

Histórico de cambios

SAS.MacoApiClient

Introducción

En el presente documento se presenta la librería SAS.MacoApiClient, que permite el acceso a datos de Maco.

Dispone de dos versiones, .NET Framework 4.5.2 y .NET Standard 2.0:

• .NET Framework 4.5.2: Permite el acceso a los datos de MACO utilizando el servicio web. Versión de la API 1.7.6
• .NET Standard 2.0: Permite el acceso a los datos de Maco utilizando dos implementaciones diferentes: una que utiliza internamente el servicio web de Maco y otra que utiliza réplica de BBDD. Versión de la API >= 2.0.0

La versión actual de la librería .NET Standard , en su versión acceso a réplica de BBDD, solo dispone de métodos para acceso a la información de módulos y perfiles.

Se recomienda la instalación de la versión de la librería .NET Standard 2.0, en su versión Servicio Web, compatible con .NET Framework desde la versión 4.6.1 de .NET Framework. por su actualización más periódica.

Dependencias

Se define las siguientes dependencia de la librería:

Versión API 1.7.6 y Versión API >= 2.0.0

Versión API >= 2.0.0

Errores conocidos

• Bug al parsear fecha en formato cadena a un formato DateTime determinado.

  Problema al parsear una fecha en formato cadena, en la que la hora solo contiene un dígito. Corregido en la versión 1.7.3 y desde de la version 2.0.2

• Bug al hacer loging con Maco: ticket devuelto nulo. Corregido en la versión 1.7.4.

Integración de la librería

Configurar en Visual Studio un nuevo origen de paquetes Nuget ( clic en “Administrar Paquetes Nuget …” del proyecto al que se desea añadir la referencia el componente MacoApiClient) indicando en el campo Origen la dirección de repositorios de componentes .NET del SAS: http://net.lib.repository.alm.sas.junta-andalucia.es/.

Versión API < 2.5.0

• • Instalar el componente SAS.MacoApiClient.

Versión API >= 2.5.0

• • Instalar el componente SAS.MacoApiClient.WebService para el acceso a datos de Maco utilizando los servicios web de Maco y validación de tickets,firma, operaciones y fecha del mensaje.
  • Solo en el caso de que se necesite consultar datos de módulos y perfil, instalar el componente SAS.MacoApiClient.ManagedDataAccess.Oracle.
  • En el caso de que solo se quiera utilizar la funcionalidad de validar ticket, firma, operaciones y fecha del mensaje, instalar SAS.MacoApiClient.Ticket.

Configuración

Prerequisitos

Previo a la configuración de la librería se debe de disponer de los siguientes datos proporcionados por la Oficina Técnica de Interoperabilidad:

• Clave pública de Maco, tanto de PRE como de PRO. Se corresponde con una clave de encriptación en formato RSA: <RSAKeyValue><Modulus>...</RSAKeyValue>
• Código del módulo del sistema en Maco. Se corresponde con el código en el que está identificado el sistema en Maco.
• Endpoints de los servicios web de Maco, tanto de PRE como de PRO. En el caso de PRE, son los siguientes:
  • https://servicios.pre.sas.junta-andalucia.es/maco/wsValidacion.asmx Servicio web de validación de Maco.
  • https://servicios.pre.sas.junta-andalucia.es/maco/ maco/wsOperador.asmx Servicio web para la gestión de datos de Operadores de Maco.
  • https://servicios.pre.sas.junta-andalucia.es/maco/ maco/wsProfesional.asmx Servicio web para la gestión de datos de Profesionales de Maco.

Otros parámetros de configuración

El validador de ticket requiere la configuración de los siguientes parámetros:

• RsaKey: Se corresponde con la Clave pública de Maco.
• ReferenceDate: Fecha de referencia utilizada para conocer si un ticket ha expirado
• FutureTicketToleranceMilli: Se utiliza para la validación de tolerancia de ticket futuro. Si su valor es inferior a 0, no se realiza validación de ticket futuro. Si su valor es mayor que 0, indica el número de milisegundos que se tolera en la validación de la fecha del ticket futuro. Si no se desea ticket a futuro, su valor se establecerá a 0.
• TicketTtlMillis: Se utiliza para validar la expiración de un ticket. Si ReferenceDate - TicketTtlMillis es superior a la fecha del ticket, se considera que el ticket ha expirado.
• TicketValidations. Listado de tipos de validación que se le aplica al ticket. Pueden ser los siguientes:
  
  • Expiración (TicketValidationType.Expired). Valida si el ticket ha expirado
  • Futuro (TicketValidationType.Future). Valida si se ha recibido un ticket con fecha futura y no cumple la tolerancia definida en el campo FutureTicketToleranceMilli.
  • Permisos (TicketValidationType.Permission). Valida que el ticket tiene los permisos adecuados para poder hacer la operación.
  • Firma (TicketValidationType.Signature). Valida que la firma del ticket sea correcta.

Procedimiento de configuración a partir de la versión 1.7.3

Cómo ejemplo de configuración, la clase UserService provee un servicio de autenticación y autorización contra el servicio de MACO.

En el ejemplo siguiente se utiliza el fichero de configuración app.config para definir los parámetros de configuración de Maco: clave pública de Maco, ruta principal servicio web de Maco y endpoints de Validación, Operador y Profesional de Maco.

<appSettings>
<add key="MacoXmlKey" value="CLAVE_PUBLICA_DE_MACO" />
<add key="MacoModule" value="CODIGO_EN_MACO_DEL_SISTEMA" />
<add key="ServiceAddressMaco" value="https://servicios.pre.sas.junta-andalucia.es/" />
<add key="EndPointAddressMacoValidacion" value="/maco/wsValidacion.asmx" />
<add key="EndPointAddressMacoOperador" value="/maco/wsOperador.asmx" />
<add key="EndPointAddressMacoProfesional" value="/maco/wsProfesional.asmx" /> 
</appSettings>

Se consulta la clave pública de Maco del fichero de configuración

string _xmlMacoKey = ConfigurationManager.AppSettings.Get("MacoXmlKey");

Se crea el objeto de configuración de Maco, MacoApiConfig. La url que recibe como parámetro se consultará de fichero de configuración o BBDD. En el ejemplo se ha utilizado la ruta inicial de PRE.

string serviceAddressMaco= ConfigurationManager.AppSettings.Get("ServiceAddressMaco");
MacoApiConfig macoApiConfig = new MacoApiConfig(serviceAddressMaco); 

Se consulta el código de módulo asignado al sistema en Maco.

macoApiConfig.ModuleCode = ConfigurationManager.AppSettings.Get("MacoModule"); 

Se define los enpoints de los diferentes servicios web de Maco en el objeto macoApiConfig: Validación, Operador y Profesionales.

string endPointAddressMacoValidacion = ConfigurationManager.AppSettings.Get("EndPointAddressMacoValidacion");
string endPointAddressMacoOperador = ConfigurationManager.AppSettings.Get("EndPointAddressMacoOperador");
string endPointAddressMacoProfesional = ConfigurationManager.AppSettings.Get("EndPointAddressMacoProfesional");


macoApiConfig.EndPoints = new Dictionary<MacoApiClient.Api.Entity.EndPointType, string>
{
         { MacoApiClient.Api.Entity.EndPointType.Validacion,  endPointAddressMacoValidacion  }, 
         { MacoApiClient.Api.Entity.EndPointType.Operador,  endPointAddressMacoOperador },
         { MacoApiClient.Api.Entity.EndPointType.Profesional,  endPointAddressMacoProfesional  }
};

Se define la configuración del validador de ticket. En el ejemplo, se comprueba que la fecha del ticket sea de 24 horas máximo y no se permite ticket a futuro (FutureTicketToleranceMillis =0).

TicketValidatorConfig ticketConfig = new TicketValidatorConfig()
            {
                RsaKey = _xmlMacoKey,
                ReferenceDate = DateTime.Now,
                FutureTicketToleranceMillis = 0,
                TicketTtlMillis = 24 * 60 * 60 * 1000,
                TicketValidations = new HashSet<TicketValidationType>()
            };

Se añaden los diferentes tipos de validaciones. En el ejemplo, validación de firma, expiración de ticket, ticket futuro y permisos.

ticketConfig.TicketValidations.Add(TicketValidationType.Signature); //SignatureTicketValidation: Valida que la firma es correcta 
ticketConfig.TicketValidations.Add(TicketValidationType.Expired); //ExpiredTicketValidation: Valida que el ticket no esté caducado 
ticketConfig.TicketValidations.Add(TicketValidationType.Future); //FutureTicketValidation: Valida que el ticket no sea futuro 
ticketConfig.TicketValidations.Add(TicketValidationType.Permission); //PermissionTicketValidation: Valida que el permiso requerido se encuentre en el ticket 

Se inicializa un objeto de tipo MacoFactory, el cual recibe un objeto configuración de la api y del ticket. Permite crear el resto de objetos necesarios para la utilización de la API.

factory = new MacoFactory(macoApiConfig, ticketConfig);

Se crea el objeto de autenticación de Maco, el cual permite realizar la autenticación o comprobar la autorización de un módulo concreto de Maco.

macoAuthentication = new MacoAuthentication(factory.MacoUserManager, macoApiConfig, factory.TicketValidator, factory.WsMacoManager, factory.MacoExceptionManager);

A continuación se presenta el código completo del ejemplo:

 public class UserService
{
        MacoFactory factory;
        MacoAuthentication macoAuthentication;
        public UserService()
        {
            string _xmlMacoKey = "CLAVE_PUBLICA_MACO"; 
       
            MacoApiConfig macoApiConfig = new MacoApiConfig("https://servicios.pre.sas.junta-andalucia.es/"); 
            macoApiConfig.ModuleCode = "MODULO_MACO_DEL_SISTEMA"; 
            macoApiConfig.EndPoints = new Dictionary<MacoApiClient.Api.Entity.EndPointType, string>
                   {
                       { MacoApiClient.Api.Entity.EndPointType.Validacion, @"/maco/wsValidacion.asmx" }, 
                       { MacoApiClient.Api.Entity.EndPointType.Operador, @"/maco/wsOperador.asmx"},
                       { MacoApiClient.Api.Entity.EndPointType.Profesional, @"/maco/wsProfesional.asmx" }
                   };

            TicketValidatorConfig ticketConfig = new TicketValidatorConfig()
            {
                RsaKey = _xmlMacoKey,
                ReferenceDate = DateTime.Now,
                FutureTicketToleranceMillis = -1,
                TicketTtlMillis = 24 * 60 * 60 * 1000,
                TicketValidations = new HashSet<TicketValidationType>()
            };
            ticketConfig.TicketValidations.Add(TicketValidationType.Signature); //SignatureTicketValidation: Valida que la firma es correcta 
            ticketConfig.TicketValidations.Add(TicketValidationType.Expired); //ExpiredTicketValidation: Valida que el ticket no este caducado 
            ticketConfig.TicketValidations.Add(TicketValidationType.Future); //FutureTicketValidation: Valida que el ticket no sea futuro 
            ticketConfig.TicketValidations.Add(TicketValidationType.Permission); //PermissionTicketValidation: Valida que el permiso requerido se encuentre en el ticket 

            factory = new MacoFactory(macoApiConfig, ticketConfig);
            macoAuthentication = new MacoAuthentication(factory.MacoUserManager, macoApiConfig, factory.TicketValidator, factory.WsMacoManager, factory.MacoExceptionManager);
        }
}

Procedimiento de configuración a partir de la versión 2.0.0

La configuración de la API depende del tipo de implementación que se vaya a utilizar, según se acceda a los datos mediante el Servicio Web de Maco o mediante réplicas de base de datos. Veamos cada una de ellas:

En ambos ejemplos se utiliza como base un proyecto .NET MVC.

Primero, en el fichero Startup.cs, método ConfigureServices, se inicializa el contenedor de inyección de dependencia:

 public void ConfigureServices(IServiceCollection services)
        {
          ...
          ContainerDI.SetAsyncScopedLifestyle(); // establecer estilo de vida por defecto del contenedor de inyección. Permite procesar tanto operaciones asíncronas como síncronas
          ContainerDI.RegisterServices(ref services); 
        ...
      } 

ContainerDI, clase del componente común SAS.Util.Injection, el cual permite el registro por inyección de dependencia de los diferentes servicios y tipos utilizados en el sistema.

Configuración de la API versión Servicio Web

En el fichero appsettings se definen secciones en las que se establece configuración de Maco: clave pública de maco y módulo del sistema en Maco, y servicio web de Maco: dirección del servicio web de Maco y los endpoints de Validación, Operador y Profesional

"MacoApiClient": { 
	"XmlKey": "CLAVEPUBLICAMACO", 
	"Module": "MODULOMACO" 
},  
"WebServiceLocator": { 
	"ServiceAddressMaco": "https://servicios.pre.sas.junta-andalucia.es/",
	"EndPointAddressMacoValidacion": "/maco/wsValidacion.asmx",
	"EndPointAddressMacoOperador": "/maco/wsOperador.asmx",
	"EndPointAddressMacoProfesional": "/maco/wsProfesional.asmx" 
},

En el fichero Startup.cs, método Configure(IApplicationBuilder app, IHostingEnvironment env), añadir la siguiente configuración de los controladores , viewcomponents de MVC y la llamada al nuevo método InitializeContainer :

 public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            ContainerDI.RegisterMvcControllers(ref app);
            ContainerDI.RegisterMvcViewComponents(ref app);          

            this.InitializeContainer();
           ...
        } 

A continuación, en el fichero Startup.cs, crear el método void InitializeContainer() y añadir la siguiente configuración para definir la configuración del validador de ticket, configuración con los endpoints de los servicios web de Maco y registrar por inyección de dependencia los diferentes servicios utilizados de la API:

 services.AddMacoWSServices (macoApiConfig,ticketValidatorConfig );

Configuración de la validación del ticket de Maco. Se define validación de firma, fecha del ticket y permisos

/// <summary>
/// Inicializador de contenedor utilizando el inyector de dependencia ContainerDI.
/// </summary>
private void InitializeContainer()
{
	var ticketValidatorConfig = new TicketValidatorConfig
	{ 
		RsaKey = ConfigurationManager.AppSettings["MacoApiClient:XmlKey"],
		ReferenceDate = DateTime.Now,
		FutureTicketToleranceMillis = -1,
		TicketTtlMillis = 24 * 60 * 60 * 1000,
		TicketValidations = new HashSet<TicketValidationType>()
	};

	ticketValidatorConfig.TicketValidations.Add(TicketValidationType.Signature); // SignatureTicketValidation: Valida que la firma es correcta 
	ticketValidatorConfig.TicketValidations.Add(TicketValidationType.Expired); // ExpiredTicketValidation: Valida que el ticket no este caducado 
	ticketValidatorConfig.TicketValidations.Add(TicketValidationType.Future); // FutureTicketValidation: Valida que el ticket no sea futuro 
	ticketValidatorConfig.TicketValidations.Add(TicketValidationType.Permission); // PermissionTicketValidation: Valida que el permiso requerido se encuentre en el ticket 

Configuración de la api de Maco, en la que se le pasa la dirección del servicio web de Maco y el código del módulo. También se define los endpoints de los servicios web de Maco.

var macoApiConfig = new MacoApiConfig(this.Configuration.GetSection("WebServiceLocator:ServiceAddressMaco").Value)
{
	ModuleCode = this.Configuration.GetSection("MacoApiClient:Module").Value
};

   macoApiConfig.EndPoints = new Dictionary<MacoApiClient.WebService.Api.Entity.EndPointType, string>
   {
           { MacoApiClient.WebService.Api.Entity.EndPointType.Validacion, Configuration.GetSection("WebServiceLocator:EndPointAddressMacoValidacion").Value },
           { MacoApiClient.WebService.Api.Entity.EndPointType.Operador, Configuration.GetSection("WebServiceLocator:EndPointAddressMacoOperador").Value},
           { MacoApiClient.WebService.Api.Entity.EndPointType.Profesional, Configuration.GetSection("WebServiceLocator:EndPointAddressMacoProfesional").Value }
   };

Registro del tipo TicketValidator que implementa la interfaz ITicketValidator. Se encarga de gestionar la validación de tickets.

ContainerDI.Register<ITicketValidator>(() => new TicketValidator(ticketValidatorConfig), ContainerDI.LifeStyleContainer.Transient); 

Registro del tipo MacoExceptionManager que implementa la interfaz IMacoExceptionManager. Se encarga de gestionar las excepciones y errores informados del servicio web de Maco.

ContainerDI.Register<IMacoExceptionManager, MacoExceptionManager>(ContainerDI.LifeStyleContainer.Transient); 

Registro del tipo MacoUserTransformer que implementa la interfaz IMacoUserTransformer. Se encarga de transformar los mensajes XML recibidos del servicio web de MACO a objetos.

ContainerDI.Register<IMacoUserTransformer, WSMacoUserTransformer>(ContainerDI.LifeStyleContainer.Transient);

Registro del tipo MacoApiConfig que implementa la interfaz IMacoApiConfig. Contiene la información de configuración de la API.

 ContainerDI.Register<IMacoApiConfig>(() => macoApiConfig, ContainerDI.LifeStyleContainer.Transient);

Registro del tipo WsMacoManager que implementa la interfaz IWsMacoActions. Es la clase wrapper encargada de llamar a los servicios web de Maco.

ContainerDI.Register<IWsMacoActions>(() => new WsMacoManager(macoApiConfig), ContainerDI.LifeStyleContainer.Transient);

Registro del servicio WSMacoAuthentication que implementa la interfaz IMacoAuthentication. Encargada de gestionar las consultas al servicio de Autenticación de Maco

ContainerDI.Register<IMacoAuthentication, WSMacoAuthentication>(ContainerDI.LifeStyleContainer.Transient);

Registro del servicio WSMacoProfessionalManager que implementa la interfaz IMacoProfessionalManager. Encargada de gestionar las consultas al servicio Profesional de Maco.

 ContainerDI.Register<IMacoProfessionalManager, WSMacoProfessionalManager>(ContainerDI.LifeStyleContainer.Transient); 

        
 Registro del servicio WSMacoOperatorManager que implementa la interfaz IMacoOperatorManager. Encargada de gestionar las consultas al servicio Operador de Maco

ContainerDI.Register<IMacoOperatorManager, WSMacoOperatorManager>(ContainerDI.LifeStyleContainer.Transient)

Configuración de la API versión Réplica de BBDD

Registro del servicio IConfigContextApiConnection, configuración del contexto de BBDD con el tipo concreto MacoContextConnection. Recibe como parámetros la cadena de conexión de la réplica, en este caso del fichero de configuración app.config, tipo de esquema Maco y nombre del esquema de la BBDD.

var macoContextConnection = new MacoContextConnection( new ManagedConfigConnectionBase<SchemaMacoType>[] { new ManagedConfigConnectionBase<SchemaMacoType>(ConfigurationManager.ConnectionStrings["MACOConnection"].ConnectionString, SchemaMacoType.Maco, "NOMBRE_ESQUEMA_REPLICA_MACO") });


ContainerDI.Register<IConfigContextApiConnection<SchemaMacoType>>(() =>macoContextConnection, ContainerDI.LifeStyleContainer.Transient);

    
Registro del tipo MacoOperatorReplicaManager que implementa la interfaz IMacoOperatorManager. Servicio encargado de consultar datos de operadores vía réplica de BBDD.

        

 ContainerDI.Register<IMacoOperatorManager, MacoOperatorReplicaManager>(ContainerDI.LifeStyleContainer.Transient);

          

          
Registro del tipo MacoRepository que implementa la interfaz IMacoRepository. Repositorio encargado de consultar datos de Maco vía réplica de BBDD.

        

 ContainerDI.Register<IMacoRepository, MacoRepository>(ContainerDI.LifeStyleContainer.Transient); 

          
 Registro del tipo MacoModuleManager que implementa la interfaz IMacoModuleManager . Servicio engargado de consultar datos de módulos en Maco vía réplica de BBDD.

ContainerDI.Register<IMacoModuleManager<object>, MacoModuleManager>(ContainerDI.LifeStyleContainer.Transient); 
}

services.AddMacoOracleServices(macoContextConnection );

A continuación se presenta el código completo del ejemplo de configuración de la versión >= 2.0.0:

 public class Startup
{
	public Startup(IConfiguration configuration)
	{
		Configuration = configuration;
	}

	public IConfiguration Configuration { get; }
	private static string _xmlMacoKey;
	private static TicketValidatorConfig _ticketValidatorConfig;

	// This method gets called by the runtime. Use this method to add services to the container.
	public void ConfigureServices(IServiceCollection services)
	{
		...
		ContainerDI.SetAsyncScopedLifestyle();
		ContainerDI.RegisterServices(ref services); 
	}

	// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
	public void Configure(IApplicationBuilder app, IHostingEnvironment env)
	{
		ContainerDI.RegisterMvcControllers(ref app);
		ContainerDI.RegisterMvcViewComponents(ref app);

		app.UseDeveloperExceptionPage();

		this.InitializeContainer(); 
		...
	}

	/// <summary>
	/// Inicializador de contenedor utilizando el inyector de dependencia ContainerDI.
	/// </summary>
	private void InitializeContainer()
	{
		#region registrar maco
			_xmlMacoKey = Configuration.GetSection("MacoApiClient:MacoXmlKey").Value;

			_ticketValidatorConfig = new TicketValidatorConfig
			{
				RsaKey = _xmlMacoKey,
				ReferenceDate = DateTime.Now,
				FutureTicketToleranceMillis = 0,
				TicketTtlMillis = 24 * 60 * 60 * 1000,

				TicketValidations = new HashSet<TicketValidationType>()
			};
			_ticketValidatorConfig.TicketValidations.Add(TicketValidationType.Signature); //SignatureTicketValidation: Valida que la firma es correcta 
			_ticketValidatorConfig.TicketValidations.Add(TicketValidationType.Expired); //ExpiredTicketValidation: Valida que el ticket no este caducado 
			_ticketValidatorConfig.TicketValidations.Add(TicketValidationType.Future); //FutureTicketValidation: Valida que el ticket no sea futuro 
			_ticketValidatorConfig.TicketValidations.Add(TicketValidationType.Permission); //PermissionTicketValidation: Valida que el permiso requerido se encuentre en el ticket 

			ContainerDI.Register<IMacoExceptionManager, MacoExceptionManager>(ContainerDI.LifeStyleContainer.Transient);
			ContainerDI.Register<IMacoUserTransformer, WSMacoUserTransformer>(ContainerDI.LifeStyleContainer.Transient);
			

			var macoApiConfig = new MacoApiConfig(Configuration.GetSection("WebServiceLocator:ServiceAddressMaco").Value)
			{
				ModuleCode = Configuration.GetSection("MacoApiClient:MacoModule").Value
			};
			macoApiConfig.EndPoints = new Dictionary<MacoApiClient.WebService.Api.Entity.EndPointType, string>
			{
				{ MacoApiClient.WebService.Api.Entity.EndPointType.Validacion, Configuration.GetSection("WebServiceLocator:EndPointAddressMacoValidacion").Value },
				{ MacoApiClient.WebService.Api.Entity.EndPointType.Operador, Configuration.GetSection("WebServiceLocator:EndPointAddressMacoOperador").Value},
				{ MacoApiClient.WebService.Api.Entity.EndPointType.Profesional, Configuration.GetSection("WebServiceLocator:EndPointAddressMacoProfesional").Value }
			};

			ContainerDI.Register<IMacoApiConfig>(() => macoApiConfig, ContainerDI.LifeStyleContainer.Transient);
			ContainerDI.Register<ITicketValidator>(() => new TicketValidator(_ticketValidatorConfig), ContainerDI.LifeStyleContainer.Transient);
			ContainerDI.Register<IWsMacoActions>(() => new WSMacoManager(macoApiConfig), ContainerDI.LifeStyleContainer.Transient);
			ContainerDI.Register<IMacoAuthentication, WSMacoAuthentication>(ContainerDI.LifeStyleContainer.Transient);
			ContainerDI.Register<IMacoOperatorManager, WSMacoOperatorManager>(ContainerDI.LifeStyleContainer.Transient);


            //descomentar en caso de consultar datos de módulo y perfil vía réplica de BBDD
 			//var macoContextConnection = new MacoContextConnection( new ManagedConfigConnectionBase<SchemaMacoType>[] { 
			//new ManagedConfigConnectionBase<SchemaMacoType>(ConfigurationManager.ConnectionStrings["MACOConnection"].ConnectionString, SchemaMacoType.Maco, "NOMBRE_ESQUEMA_REPLICA_MACO") }); 
			//ContainerDI.Register<IConfigContextApiConnection<SchemaMacoType>>(() =>macoContextConnection, ContainerDI.LifeStyleContainer.Transient);
			//ContainerDI.Register<IMacoOperatorManager, MacoOperatorReplicaManager>(ContainerDI.LifeStyleContainer.Transient);
			//ContainerDI.Register<IMacoRepository, MacoRepository>(ContainerDI.LifeStyleContainer.Transient);
			//ContainerDI.Register<IMacoModuleManager<object>, MacoModuleManager>(ContainerDI.LifeStyleContainer.Transient);

		#endregion registrar maco	
	}
}

using SAS.MacoApiClient.WebService.IoC;
//using SAS.MacoApiClient.ManagedDataAccess.Oracle.IoC; 
public class Startup
{
	public Startup(IConfiguration configuration)
	{
		Configuration = configuration;
	}

	public IConfiguration Configuration { get; }
	private static string _xmlMacoKey;
	private static TicketValidatorConfig _ticketValidatorConfig;

	// This method gets called by the runtime. Use this method to add services to the container.
	public void ConfigureServices(IServiceCollection services)
	{

		#region Inyección de dependencia utilizando el inyector por defecto de .NET

			#region registrar Maco
			_xmlMacoKey = Configuration.GetSection("MacoApiClient:MacoXmlKey").Value;

			_ticketValidatorConfig = new TicketValidatorConfig
			{
				RsaKey = _xmlMacoKey,
				ReferenceDate = DateTime.Now,
				FutureTicketToleranceMillis = 0,
				TicketTtlMillis = 24 * 60 * 60 * 1000,

				TicketValidations = new HashSet<TicketValidationType>()
			};
			_ticketValidatorConfig.TicketValidations.Add(TicketValidationType.Signature); //SignatureTicketValidation: Valida que la firma es correcta 
			_ticketValidatorConfig.TicketValidations.Add(TicketValidationType.Expired); //ExpiredTicketValidation: Valida que el ticket no este caducado 
			_ticketValidatorConfig.TicketValidations.Add(TicketValidationType.Future); //FutureTicketValidation: Valida que el ticket no sea futuro 
			_ticketValidatorConfig.TicketValidations.Add(TicketValidationType.Permission); //PermissionTicketValidation: Valida que el permiso requerido se encuentre en el ticket 

			var macoApiConfig = new MacoApiConfig(Configuration.GetSection("WebServiceLocator:ServiceAddressMaco").Value)
			{
				ModuleCode = Configuration.GetSection("MacoApiClient:MacoModule").Value
			};
			macoApiConfig.EndPoints = new Dictionary<SAS.MacoApiClient.WebService.Api.Entity.EndPointType, string>
			{
				{ SAS.MacoApiClient.WebService.Api.Entity.EndPointType.Validacion, Configuration.GetSection("WebServiceLocator:EndPointAddressMacoValidacion").Value },
				{ SAS.MacoApiClient.WebService.Api.Entity.EndPointType.Operador, Configuration.GetSection("WebServiceLocator:EndPointAddressMacoOperador").Value},
				{ SAS.MacoApiClient.WebService.Api.Entity.EndPointType.Profesional, Configuration.GetSection("WebServiceLocator:EndPointAddressMacoProfesional").Value }
			};

			//registro de servicios de la API MacoApiClient implementación webservices utilizando el inyector de dependencia por defecto de .NET
			services.AddMacoWSServices(macoApiConfig, _ticketValidatorConfig);
			
			#endregion
			#region registrar servicios Maco que acceden a datos vía réplica BBDD
				//descomentar en caso de consultar datos de módulo y perfil vía réplica de BBDD 
				//var macoContextConnection = new MacoContextConnection( new ManagedConfigConnectionBase<SchemaMacoType>[] { 
					//new ManagedConfigConnectionBase<SchemaMacoType>(ConfigurationManager.ConnectionStrings["MACOConnection"].ConnectionString, SchemaMacoType.Maco, "NOMBRE_ESQUEMA_REPLICA_MACO") }); 
			   //services.AddMacoOracleServices(macoContextConnection);
			#endregion

		#endregion Inyección de dependencia utilizando el inyector por defecto de .NET
	}
}

Uso

A continuación se describe el uso de la librería.

Funcionalidades utilizando Servicio Web de Maco Autenticación

Para poder realizar la autenticación y autorización con Maco se deberá de hacer uso de la clase MacoAuthentication, mediante el uso del método LoginAuthentication() que devuelve un objeto MacoUser, y con el que se podrá realizar la autenticación con Maco. Si la autenticación no se ha podido realizar con éxito se lanzará una excepción de tipo MacoException. .

Ejemplo:

public MacoUser login(string username, string password) { 
	return _macoAuthentication.LoginAuthentication(username, password); 
} 

Para realizar la comprobación de autorización de un módulo concreto con Maco se deberá de hacer uso del método ServiceAuthorization(). Si la autorización no se ha podido realizar con éxito se lanzará una excepción de tipo MacoException.

Ejemplo:

public boolean autorizarServicio(MacoUser user, string requestedService) { 
	return _macoAuthentication.ServiceAuthorization(user, requestedService); 
}

Para realizar la comprobación de autenticación y autorización de un módulo concreto con Maco se deberá de hacer uso del método LoginAuthentication, pasando como argumento username, password y código del módulo en Maco. Si la autorización no se ha podido realizar con éxito se lanzará una excepción de tipo MacoException.

Ejemplo:

public boolean LoginAuthentication(string username, string password,string moduleCode) { 
	return _macoAuthentication.LoginAuthentication(username, password,moduleCode); 
}

Operadores

Para poder buscar operadores en Maco se deberá de hacer uso de la función FindOperator, para un solo resultado, o FindOperators, para múltiples resultados. Los campos que pueden ser usados en el dto para la búsqueda son:

UsersPerPage: Número de usuarios por página PageNumber: Numero de la página a recibir Name: Nombre a buscar (puede ser parcial) FirstSurname: Apellido 1 (puede ser parcial) SecondSurname: Apellido 2 (Puede ser parcial) Login: login del usuario DirayaCode: código de diraya ModuleCode: código del módulo UnitCode: código de la unidad organizativa UnitTypeCode: tipo de unidad organizativa

Ejemplo:

public MacoUser BuscarUsuarioPorLogin(string login) { 
	QuerysUserSearchDto querysUserSearchDto= new QuerysUserSearchDto(); 
	querysUserSearchDto.PageNumber= 1; 
	querysUserSearchDto.UsersPerPage = 1; 
	querysUserSearchDto.Login = login; 
	return _macoOperatorManager.FindOperator(usuarioMacoQueRealizaLaPeticion, querysUserSearchDto); 
} 

//Permite la búsqueda por nombre, devuelve una lista de usuarios 
public PaginationList<MacoUser> BuscarUsuariosPorNombre(string name) { 
	QuerysUserSearchDto querysUserSearchDto= new QuerysUserSearchDto(); 
	querysUserSearchDto.PageNumber = 1; 
	querysUserSearchDto.UsersPerPage = 10; 
	querysUserSearchDto.Name = name; 
	return _macoOperatorManager.FindOperators(usuarioMacoQueRealizaLaPeticion, querysUserSearchDto); 
}

Para realizar un cambio de contraseña de un usuario en Maco, se deberá de hacer uso de la función ChangeUserPassword:

//realiza un cambio de contraseña 
public void CambiarContraseña(MacoUser user, string password) { 
	//la manera de generar una contraseña que acepte MACO puede variar y debe de ser consultada en la documentación de MACO.
	var passwordRSA = MacoUtil.RSA(password,rsaKey); 
	// rsaKey es la clave pública de Maco: <RSAKeyValue><Modulus>...</RSAKeyValue> proporcionada por la Oficina Técnica de Interoperabilidad 
	_macoOperatorManager.ChangeUserPassword(user, passwordRSA); 
}

siendo _macoOperatorManager un objeto de tipo IMacoOperatorManager.

Profesionales

Para poder buscar profesionales en Maco se deberá de hacer uso de la función FindProfessional, para un solo resultado, o FindProfessionals ,para múltiples resultados, de la misma manera que se realiza con los Operadores. Los campos que, adicionalmente a los descritos en Operador, podrán ser usados son los siguientes:

• • • ProfessionalCode: Código de profesional.
    • LicenseNumber: Código de Colegiado.
    • ProfessionalType : Tipo de profesional.
    • ProfessionalSpecialtyCode : Código de la especialidad del profesional.
    • StatusCode: Estado del usuario, cuyos posibles valores son:StatusAny, StatusActive, StatusPassive, StatusLocked, StatusChangePassword.

Validación de tickets Maco

• • Si se quiere validar un ticket + permisos concretos, se realizará pasándole la lista de permisos a validar en la llamada IsTicketValid. Por ejemplo:

List<string> permissions = new List<string>() { "CUSTOMPERMISSION", "CUSTOMPERMISSION2" }; 
HashSet<string> hSetPermissions = new HashSet<string>(permissions); 
return new _ticketValidator.IsTicketValid(ticket,null, hSetPermissions)

• • Si solo se quiere validar los valores por defecto, registrados por inyección de dependencia en la configuración TicketValidatorConfig, no será necesario pasarle la lista de permisos:

private bool Validate(string ticket, string signature) { 
	return new _ticketValidator.IsTicketValid(ticket, signature); 
}

Siendo _ticketValidator un objeto de tipo ITicketValidator.

• • En el siguiente ejemplo se muestra la validación de ticket, firma, operación y fecha de un mensaje:

private bool ValidarTicket(string sTicketEntrada, string sFirmaEntrada, string sOperacionEntrada, DateTime dtFechaMensaje)
        {
            var _xmlMacoKey = "CLAVE_PUBLICA_MACO";
            var result;
            var _ticketValidatorConfig = new TicketValidatorConfig
            {
                RsaKey = _xmlMacoKey,
                ReferenceDate = dtFechaMensaje,
                FutureTicketToleranceMillis = 0,
                TicketTtlMillis = 24 * 60 * 60 * 1000,

                TicketValidations = new HashSet<TicketValidationType>()
            };
            _ticketValidatorConfig.TicketValidations.Add(TicketValidationType.Signature); //SignatureTicketValidation: Valida que la firma es correcta 
            _ticketValidatorConfig.TicketValidations.Add(TicketValidationType.Expired); //ExpiredTicketValidation: Valida que el ticket no este caducado 
            _ticketValidatorConfig.TicketValidations.Add(TicketValidationType.Future); //FutureTicketValidation: Valida que el ticket no sea futuro 
            _ticketValidatorConfig.TicketValidations.Add(TicketValidationType.Permission); //Valida que los permisos son los indicados en el ticket

            List<string> permissions = new List<string>() { sOperacionEntrada }; //si sOperacionEntrada está formado por diferentes permisos separados por un caracter separador, realizar una operación Split por dicho caracter separador
            HashSet<string> hSetPermissions = new HashSet<string>(permissions);

            var ticketValidator = new TicketValidator(_ticketValidatorConfig);
            try
            {
                result = ticketValidator.IsTicketValid(sTicketEntrada, sFirmaEntrada, hSetPermissions);
            }
            catch (MacoException me)
            {
                result = false;
            }

            return result;
        }

En el ejemplo anterior se crea un objeto de tipo TicketValidator con el operador "new". En el caso de haber usado inyección por dependencia para la configuración de los servicios, sólo habría que obtener una instancia de ITicketValidator y asignarle en el atributo Config, ticketValidator.Config, la configuración _ticketValidatorConfig adecuada.

En el siguiente ejemplo se muestra métdoos de autenticación de un usuario y validación de un ticket utilizando interfaces:

	private IMacoAuthentication _macoAuthentication;
	private ITicketValidator _ticketValidator;


	public UserService( IMacoAuthentication macoAuthentication, ITicketValidator ticketValidator)
	{
		_macoAuthentication = macoAuthentication;
		_ticketValidator = ticketValidator;
	}

	public MacoUser LoginAuthentication(string loginName, string password, string moduleCode)
	{
		try
		{
			return _macoAuthentication.LoginAuthentication(loginName, password, moduleCode);
		}
		catch (Exception ex)
		{
			throw ex;
		}
	}

	public bool IsTicketValid(string ticket, string ticketSignature)
	{
		return _ticketValidator.IsTicketValid( ticket, ticketSignature);
	}