BeWoPlaner/Service/Core/ServiceHelper.cs

using System;
using System.Reflection;
using System.Runtime.Remoting.Channels;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Text;
using System.Threading.Tasks;
using BeWo.Service.ServiceContracts;
using System.ServiceModel.Dispatcher;
using BeWo.Service.Attributes;
using BeWo.Service.ServiceUtils;
using BS.Shared.Extensions;

namespace BeWo.Service.Core
{
	public static class ServiceHelper
	{
		public static FileLogger CoreLogger { get; } = new FileLogger(MergedConfig.GetSetting(WebConfigSetting.ServiceLogFilePath));
		public static FileLogger WCFErrorLogger { get; } = new FileLogger(MergedConfig.GetSetting(WebConfigSetting.WCFErrorLogFilePath));
		public static FileLogger JsonErrorLogger { get; } = new FileLogger(MergedConfig.GetSetting(WebConfigSetting.JsonErrorLogFilePath));

		public static Tuple<string, string> GetInterfaceAndMethodWCF(Message request, IClientChannel channel)
		{
			var lTemp = request.Headers.Action.Split("/");
			string lMethodName = lTemp[lTemp.Count - 1];
			string lServiceInterface = lTemp[lTemp.Count - 2];
			return new Tuple<string, string>(lServiceInterface, lMethodName);
		}
		public static Tuple<string, string> GetInterfaceAndMethodASP(Message request, IClientChannel channel)
		{
			// Hole Interface
			string lInterface = null;
			var segments = channel.LocalAddress.Uri.Segments;
			for (int i = 0; i < segments.Length; i++)
			{
				var seg = segments[i].Trim('/');

				if (seg.EndsWith(".svc"))
				{
					lInterface = "I" + seg.Substring(0, seg.Length - 4);
				}
			}

			if (string.IsNullOrWhiteSpace(lInterface))
			{
				throw new ArgumentException($"Zugriff verweigert. Interface unbekannt");
			}

			// Hole Methode
			string lMethod = request.Properties[WebHttpDispatchOperationSelector.HttpOperationNamePropertyName] as string;
			if (string.IsNullOrWhiteSpace(lMethod))
			{
				throw new ArgumentException($"Zugriff verweigert. Methode unbekannt");
			}

			return new Tuple<string, string>(lInterface, lMethod);
		}

		public static T GetCustomAttribute<T>(Uri baseAddress, Uri request) where T : Attribute
		{
			// Hole Interface
			string lInterface = null;
			var segments = baseAddress.Segments;
			for (int i = 0; i < segments.Length; i++)
			{
				var seg = segments[i].Trim('/');

				if (seg.EndsWith(".svc"))
				{
					lInterface = seg.Substring(0, seg.Length - 4);
				}
			}

			// Falls kein Interface gefunden wird
			if (string.IsNullOrWhiteSpace(lInterface))
			{
				throw new ArgumentException($"Zugriff verweigert. Interface unbekannt");
			}

			// Wird für URLTemplate != Methodname verwendet
			var name = $"BeWo.Service.ServiceContracts.I{lInterface}";
			var t = Type.GetType(name);
			var resolver = new UriTemplateResolver(baseAddress, t);
			var method = resolver.ResolveMethod(request.AbsoluteUri);
			var methodInfo = t.GetMethod(method);

			// Rückgabe
			return getCustomAttribute<T>(methodInfo);
		}

		public static T GetCustomAttribute<T>(Message request, IClientChannel channel) where T : Attribute
		{
			var (inter, method) = GetInterfaceAndMethodASP(request, channel);
			var authentification = GetCustomAttribute<T>(inter, method);
			return authentification;
		}
		public static T GetCustomAttribute<T>(string pServiceInterface, string pMethodName) where T : Attribute
		{
			MethodInfo methodInfo = null;

			try
			{
				// Hole entsprechende Methode
				var name = $"BeWo.Service.ServiceContracts.{pServiceInterface}";
				var t = Type.GetType(name);
				methodInfo = t?.GetMethod(pMethodName);
			}
			catch (Exception)
			{
				throw new ArgumentException($"Zugriff verweigert. Interface oder Methode unbekannt");
			}

			return getCustomAttribute<T>(methodInfo);
		}

		private static T getCustomAttribute<T>(MethodInfo methodInfo) where T : Attribute
		{
			if (methodInfo == null)
			{
				throw new ArgumentException($"Zugriff verweigert. Interface oder Methode unbekannt");
			}

			// Hole Custome Attribute
			var attribute = methodInfo.GetCustomAttribute<T>();

			return attribute;
		}
	}
}