public object CreateInstance(ServiceUnitContext suContext, Type instanceType)
{
suContext.ServiceContainer.AddTransient(instanceType);
var result = suContext.ServiceContainer.GetService(instanceType) as IHttpHandler;
return(result);
}
public object CreateInstance(ServiceUnitContext suContext, Type instanceType)
{
var container = suContext.ServiceContainer;
container.AddTransient(instanceType);
return(container.GetService(instanceType));
}
public ServiceUnitResponse InvokeAction(ServiceUnitContext suContext, ActionDefinition action)
{
var handler = action.Instance as IHttpHandler;
handler.ProcessRequest(HttpContext.Current);
return(new ServiceUnitResponse(HttpStatusCode.OK));
}
public async Task Invoke(IDictionary <string, object> environment)
{
var context = new OwinContext(environment);
var url = context.Request.Path.Value;
if (context.Request.QueryString.HasValue)
{
url = url + "?" + context.Request.QueryString.Value;
}
var suContext = new ServiceUnitContext(url, context.Request.User);
if (suContext != null && suContext.Request != null)
{
context.Request.SetServiceUnitContext(suContext);
}
if (this.settings.ContextCreatedHandler != null)
{
this.settings.ContextCreatedHandler(suContext);
}
if (this.next != null)
{
await this.next.Invoke(environment);
}
}
public ActionDefinition GetAction(ServiceUnitContext suContext, object instance)
{
return(new ActionDefinition()
{
Instance = instance
});
}
public ActionDefinition GetAction(ServiceUnitContext suContext, object instance)
{
return(new ActionDefinition()
{
Method = instance.GetType().GetMethod("ProcessRequest", BindingFlags.Public | BindingFlags.Instance),
Instance = instance
});
}
public ServiceUnitResponse InvokeAction(ServiceUnitContext suContext, ActionDefinition action)
{
var response = new ServiceUnitResponse(HttpStatusCode.OK);
response.Data = action.Method.Invoke(action.Instance, new object[0]);
return(response);
}
private Type MapPath(ServiceUnitContext suContext)
{
var classAbstractPath = string.Format("/{0}/{1}/{2}/Api/{3}Controller",
suContext.ServiceUnitName, suContext.Version, suContext.Role,
suContext.Request.ProcessPath.Split(new[] { '/' })[1]);
var typePath = suContext.ServiceContainer.GetService <ITypePath>();
return(typePath.GetType(classAbstractPath));
}
public RoleBasedAuthorization(ServiceUnitContext context)
{
Contract.NotNull(context, "context");
this.context = context;
roleManager = new RoleManager();
permissionManager = new PermissionManager();
targetManager = new TargetManager();
userRoleManager = new UserRoleManager();
}
public ServiceUnitResponse Execute(ServiceUnitContext suContext, IUriProcessResolver resolver)
{
Contract.NotNull(suContext, "suContext");
Contract.NotNull(resolver, "resolver");
using (var logger = new TraceLogger(suContext))
{
return(ExecuteInternal(suContext, resolver));
}
}
private static bool IsNeedTestMode(ServiceUnitContext context)
{
var specifics = context.Request.SpecificProcessPath;
if (string.IsNullOrWhiteSpace(specifics))
{
return(false);
}
return("/TEST".Equals(specifics, StringComparison.InvariantCultureIgnoreCase));
}
public object CreateInstance(ServiceUnitContext suContext, Type instanceType)
{
var classAbstractPath = string.Format("/{0}/{1}/Resources/{2}",
suContext.ServiceUnitName, suContext.Version, suContext.Request.ProcessPath.Split(new[] { '/' })[1]);
var typePath = suContext.ServiceContainer.GetService <ITypePath>();
var type = typePath.GetType(classAbstractPath);
var resourceManager = new ResourceManager(type.FullName, type.Assembly);
return(new ResourceHolder(resourceManager));
}
/// <summary>
/// パイプラインで利用するコンテキスト <see cref="PipeContext"/> を生成します。
/// </summary>
/// <param name="serviceContext"></param>
/// <returns></returns>
public static PipeContext CreatePipeContext(this ServiceUnitContext serviceContext, object requestData)
{
PipeContext result = new PipeContext(serviceContext.ServiceContainer);
result.RequestData = requestData;
result.Items.Add(PipeContextKeys.LogContext, serviceContext.LogContext);
result.Items.Add(PipeContextKeys.VersionFisicalDirectory, serviceContext.GetVersionFisicalDirectory());
return(result);
}
private void WriteErrorLog(ServiceUnitContext serviceUnitContext, Exception ex)
{
var data = new LogData()
{
Exception = ex,
Uri = serviceUnitContext.Request.Path,
User = serviceUnitContext.User == null ? null : serviceUnitContext.User.Identity.Name,
LogName = "error",
LogId = serviceUnitContext.Id
};
serviceUnitContext.LogContext.Logger.Error(data);
}
private ServiceUnitResponse HandleError(ServiceUnitContext context,
IUriProcessResolver resolver,
ServiceUnitResponse response)
{
if (resolver != null)
{
foreach (var handler in resolver.HandleErrorPipeline)
{
handler.Invoke(context, response);
}
}
return(response);
}
public ActionDefinition GetAction(ServiceUnitContext suContext, object instance)
{
var uriMethodName = suContext.Request.ProcessPath.Split(new[] { '/' })[2];
var methodInfo = instance.GetType().GetMethod(uriMethodName, BindingFlags.Instance | BindingFlags.Public);
if (methodInfo == null)
{
return(null);
}
return(new ActionDefinition()
{
Method = methodInfo,
Instance = instance
});
}
private static bool CanTestMode(ServiceUnitContext context)
{
var config = context.Configuration;
if (!config.Items.ContainsKey(ConfigKey) || !(config.Items[ConfigKey] is IEnumerable <string>))
{
if (!config.Raw.Keys.Contains(ConfigKey))
{
return(false);
}
var modes = config.Raw[ConfigKey].ToObject <string[]>();
config.Items[ConfigKey] = modes;
}
return(((IEnumerable <string>)config.Items[ConfigKey]).Contains("test", StringComparer.InvariantCultureIgnoreCase));
}
public Type GetExecutionType(ServiceUnitContext suContext)
{
var info = suContext;
var pageName = string.Format("~/ServiceUnits/{0}/{1}/{2}/Pages/{3}.aspx",
suContext.ServiceUnitName, suContext.Version,
suContext.Role, suContext.Request.ProcessPath.Split(new[] { '/' })[1]);
var factory = BuildManager.GetObjectFactory(pageName, false);
if (factory != null)
{
return(BuildManager.GetCompiledType(pageName));
}
return(null);
}
public static bool IsTestMode(this ServiceUnitContext context)
{
if (context == null)
{
context.Properties[PageTestModeKey] = false;
return(false);
}
var result = false;
if (context.Properties.ContainsKey(PageTestModeKey))
{
return((bool)context.Properties[PageTestModeKey]);
}
if (CanTestMode(context) && IsNeedTestMode(context))
{
result = true;
}
context.Properties[PageTestModeKey] = result;
return(result);
}
public ServiceUnitResponse InvokeAction(ServiceUnitContext suContext, ActionDefinition action)
{
var holder = action.Instance as ResourceHolder;
var resourceSetWizCul = RetrieveResourceSetWithCulture(suContext, holder);
if (resourceSetWizCul == null)
{
return(new ServiceUnitResponse(HttpStatusCode.NotFound));
}
var result = AsEnumerable(resourceSetWizCul.Item1)
.Where(e => e.Key is string && e.Value is string)
.Aggregate(new Dictionary <string, string>(), (dic, de) =>
{
dic.Add(de.Key.ToString(), de.Value.ToString());
return(dic);
});
return(new ServiceUnitResponse(HttpStatusCode.OK)
{
Data = new ResourceResponseData(result, resourceSetWizCul.Item2)
});
}
private Tuple <ResourceSet, CultureInfo> RetrieveResourceSetWithCulture(ServiceUnitContext suContext, ResourceHolder holder)
{
var resourceManager = holder.Manager;
var culture = CultureInfo.InvariantCulture;
CultureInfo targetCulture = CultureInfo.InvariantCulture;
ResourceSet resourceSet = null;
if (suContext.Request.Query.ContainsKey(CultureParameterName))
{
var paramCultures = suContext.Request.Query[CultureParameterName].Split(',');
foreach (var paramCulture in paramCultures)
{
culture = targetCulture = new CultureInfo(paramCulture);
while (true)
{
if (culture.Name == CultureInfo.InvariantCulture.Name)
{
break;
}
resourceSet = resourceManager.GetResourceSet(culture, true, false);
if (resourceSet != null)
{
break;
}
culture = culture.Parent;
}
if (resourceSet != null)
{
break;
}
}
}
if (resourceSet == null)
{
resourceSet = resourceManager.GetResourceSet(CultureInfo.InvariantCulture, true, false);
}
return(new Tuple <ResourceSet, CultureInfo>(resourceSet, targetCulture));
}
public static void SetServiceUnitContext(this HttpRequestMessage request, ServiceUnitContext target)
{
request.Properties.Add(ServiceUnitContextKey, target);
}
public PdfDocumentController(ServiceUnitContext serviceUnitContext)
{
this.serviceUnitContext = serviceUnitContext;
}
public Type GetExecutionType(ServiceUnitContext suContext)
{
return(this.MapPath(suContext));
}
public static void SetServiceUnitContext(this HttpContextBase context, ServiceUnitContext target)
{
context.Items.Add(ServiceUnitContextKey, target);
}
public static void SetServiceUnitContext(this IOwinRequest request, ServiceUnitContext suContext)
{
request.Set <ServiceUnitContext>(ServiceUnitContextKey, suContext);
}
private ServiceUnitResponse ExecuteInternal(ServiceUnitContext suContext, IUriProcessResolver resolver)
{
var executionType = resolver.GetExecutionType(suContext);
ServiceUnitResponse response = null;
if (executionType == null)
{
response = new ServiceUnitResponse(HttpStatusCode.NotFound);
HandleError(suContext, resolver, response);
return(response);
}
var instance = resolver.CreateInstance(suContext, executionType);
if (instance == null)
{
response = new ServiceUnitResponse(HttpStatusCode.NotFound);
HandleError(suContext, resolver, response);
return(response);
}
var action = resolver.GetAction(suContext, instance);
if (action == null)
{
response = new ServiceUnitResponse(HttpStatusCode.NotFound);
HandleError(suContext, resolver, response);
return(response);
}
try
{
IRoutingAuthorization auth = suContext.ServiceContainer.GetService <IRoutingAuthorization>();
var authResult = auth.Authorize();
if (!authResult.IsAuthorized)
{
response = new ServiceUnitResponse(authResult.Status);
HandleError(suContext, resolver, response);
return(response);
}
response = resolver.InvokeAction(suContext, action);
if (response == null)
{
return(new ServiceUnitResponse(HttpStatusCode.NotFound));
}
if (response.StatusCode != HttpStatusCode.OK)
{
HandleError(suContext, resolver, response);
}
}
catch (Exception ex)
{
WriteErrorLog(suContext, ex);
return(HandleError(suContext, resolver, new ServiceUnitResponse(HttpStatusCode.InternalServerError)
{
Data = ex
}));
}
return(response);
}
private void OnServiceUnitContextCreated(ServiceUnitContext context)
{
context.ServiceContainer.AddSingleton(typeof(EmployeeInformation));
context.ServiceContainer.AddInstance(typeof(Archpack.Training.ArchUnits.Routing.V2.IRoutingAuthorization), new RoleBasedAuthorization(context));
}
public ActionDefinition GetAction(ServiceUnitContext suContext, object instance)
{
throw new NotImplementedException();
}
public ServiceUnitResponse InvokeAction(ServiceUnitContext suContext, ActionDefinition action)
{
throw new NotImplementedException();
}
