private void ConfigureAgatha()
{
var agathaContainer = new Container(Container);
IoC.Container = agathaContainer;
Container.RegisterInstance <IContainer> (agathaContainer);
var clientConfiguration = new ClientConfiguration(agathaContainer)
{
AsyncRequestDispatcherImplementation = typeof(AsyncRequestDispatcher)
};
KnownTypeProvider.Register(typeof(LookupValueDto));
KnownTypeHelper.RegisterNonGenericRequestsAndResponses(typeof(InfrastructureModule).Assembly);
clientConfiguration.AddRequestAndResponseAssembly(typeof(GetLookupValuesRequest).Assembly);
var genericsToApply = KnownTypeHelper.GetGenerics(typeof(Const).Assembly);
KnownTypeHelper.RegisterGenerics(genericsToApply, typeof(InfrastructureModule).Assembly);
KnownTypeHelper.RegisterKnownTypesFromIKnownTypeProviders(typeof(IMetadataItemDto).Assembly); // metadata
clientConfiguration.RequestProcessorImplementation = typeof(CustomAsyncRequestProcessorProxy);
clientConfiguration.Initialize();
}
protected T[] GetRequests <T>(NameValueCollection collection)
{
ValidateCollection(collection);
var requests = new List <T>();
if (IsSingleRequestCollection(collection))
{
var type = KnownTypeProvider.GetKnownTypes(null).Where(x => x.Name == collection.Get("request")).FirstOrDefault();
if (type == null)
{
throw new InvalidOperationException("Cannot resolve the name of the Request Type");
}
requests.Add((T)RecurseType(collection, type, null));
}
else
{
var collections = SplitTypeCollections(collection);
foreach (var splitCollection in collections)
{
var type = KnownTypeProvider.GetKnownTypes(null).Where(x => x.Name == splitCollection.Get("request")).FirstOrDefault();
if (type == null)
{
throw new InvalidOperationException("Cannot resolve the name of the Request Type");
}
var request = (T)RecurseType(splitCollection, type, null);
requests.Add(request);
}
}
return(requests.ToArray());
}
private void RegisterRequestAndResponseTypes()
{
foreach (var assembly in requestsAndResponseAssemblies)
{
KnownTypeProvider.RegisterDerivedTypesOf <Request>(assembly);
KnownTypeProvider.RegisterDerivedTypesOf <Response>(assembly);
}
}
protected ClientComponentResolving()
{
IoC.Container = null;
KnownTypeProvider.ClearAllKnownTypes();
var configuration = new ClientConfiguration(Assembly.GetExecutingAssembly(), Activator.CreateInstance <TContainer>());
configuration.AddRequestAndResponseAssembly(typeof(RequestB).Assembly);
configuration.Initialize();
}
public void RegisterRequestAndResponseTypes(params Assembly[] assemblies)
{
foreach (var assembly in assemblies)
{
KnownTypeProvider.AddKnownTypes(_requestResponseSerice.GetAsyncRequestTypes(assembly));
KnownTypeProvider.AddKnownTypes(_requestResponseSerice.GetAsyncResponseTypes(assembly));
KnownTypeProvider.AddKnownTypes(_requestResponseSerice.GetSyncRequestTypes(assembly));
KnownTypeProvider.AddKnownTypes(_requestResponseSerice.GetSyncResponseTypes(assembly));
}
}
/// <summary>
/// Configures the agatha.
/// </summary>
/// <param name="appContainer">The app container.</param>
protected virtual void ConfigureAgatha(IContainer appContainer)
{
var structureMapContainer = new Agatha.StructureMap.Container(appContainer);
IoC.Container = structureMapContainer;
var assemblyLocator = appContainer.GetInstance <IAssemblyLocator> ();
var infrastructureAssemblies = assemblyLocator.LocateInfrastructureAssemblies();
var genericsToApply = new Dictionary <Type, Type> ();
foreach (var infrastructureAssembly in infrastructureAssemblies)
{
var genericsToApplyInAssebmly = KnownTypeHelper.GetGenerics(infrastructureAssembly);
foreach (KeyValuePair <Type, Type> keyValuePair in genericsToApplyInAssebmly)
{
genericsToApply.Add(keyValuePair.Key, keyValuePair.Value);
}
}
var serviceLayerConfiguration = new ServiceLayerConfiguration(structureMapContainer);
var serviceAssemblies = assemblyLocator.LocateWebServiceAssemblies();
foreach (var assembly in serviceAssemblies)
{
var assemblyRef = assembly;
Logger.Debug("Registering Requests, Responses, Handlers, and Dtos for Assembly: {0}", assemblyRef);
KnownTypeHelper.RegisterNonGenericRequestsAndResponses(assembly);
serviceLayerConfiguration.AddRequestHandlerAssembly(assembly);
KnownTypeProvider.RegisterDerivedTypesOf <AbstractDataTransferObject> (assembly.GetTypes().Where(t => !t.IsGenericType));
KnownTypeHelper.RegisterGenerics(genericsToApply, assembly);
}
KnownTypeProvider.Register <TerminologyConcept> ();
KnownTypeProvider.Register <TerminologyProperty> ();
KnownTypeProvider.Register <TerminologyPropertyType> ();
KnownTypeProvider.Register <TerminologyVocabulary> ();
// register the agatha interceptors
serviceLayerConfiguration.RegisterRequestHandlerInterceptor <SecurityInterceptor>();
serviceLayerConfiguration.RegisterRequestHandlerInterceptor <RuleViolationEventInterceptor> ();
serviceLayerConfiguration.RequestProcessorImplementation = typeof(Service.PerformanceLoggingRequestProcessor);
serviceLayerConfiguration.Initialize();
RegisterIRequestHandlerOfGetRequestDtoByKey(appContainer);
CallKnownTypeProviders(appContainer);
}
/// <summary>
/// Registers the requests and responses.
/// </summary>
/// <param name="assembly">The assembly.</param>
public static void RegisterRequestsAndResponses(Assembly assembly)
{
var list = new List <Type> ();
list.AddRange(GetNonGenericRequestsAndResponses(assembly));
list.AddRange(GetGenericRequestsAndResponses(assembly));
foreach (var type in list)
{
KnownTypeProvider.Register(type);
}
}
/// <summary>
/// Registers the non generic requests and responses for an assembly.
/// </summary>
/// <param name="assembly">The assembly.</param>
public static void RegisterNonGenericRequestsAndResponses(Assembly assembly)
{
var nonGenericTypes = (from t in assembly.GetTypes()
where
t.IsAbstract == false && t.IsGenericTypeDefinition == false &&
(t.IsSubclassOf(typeof(Request)) || t.IsSubclassOf(typeof(Response)))
select t).ToArray();
foreach (var nonGenericType in nonGenericTypes)
{
KnownTypeProvider.Register(nonGenericType);
}
}
public void RegisterTypes_InSpecificAssembly_Succeed()
{
var assembly = typeof(IMetadataItemDto).Assembly;
var metadataKnowTypeProvider = new MetadataKnownTypeProvider(assembly);
metadataKnowTypeProvider.RegisterTypes();
var knownTypes = KnownTypeProvider.GetKnownTypes(null).ToList();
var expectedKnownTypes = assembly.GetExportedTypes()
.Where(x => typeof(IMetadataItemDto).IsAssignableFrom(x))
.ToList();
CollectionAssert.AreEqual(expectedKnownTypes, knownTypes);
}
public static void RegisterWCFAgathaTypes(Assembly assembly)
{
// Taken from - http://www.xavierdecoster.com/post/2010/05/07/Automate-WCF-KnownTypes-in-a-3-Tier-Silverlight-application.aspx
// get all public types
var publicTypes = assembly.GetExportedTypes();
// get all data contracts
var dataContracts = publicTypes.Where(type => type.GetCustomAttributes(typeof(DataContractAttribute), true).Length > 0);
// register all data contracts to WCF (using Agatha)
// notice that we have to provide a base type to Agatha's KnownTypeProvider (it does not support interfaces...), so what the heck, let's use object :-)
KnownTypeProvider.RegisterDerivedTypesOf <object>(dataContracts);
}
/// <summary>
/// Registers the generics.
/// </summary>
/// <param name="generics">The generics.</param>
/// <param name="assembly">The assembly.</param>
public static void RegisterGenerics(Dictionary <Type, Type> generics, Assembly assembly)
{
foreach (var genericType in generics.Keys)
{
var typesToApply = from t in assembly.GetTypes()
where !t.IsGenericType && t.IsSubclassOf(generics[genericType])
select t;
foreach (var type in typesToApply)
{
Type genericType1 = genericType;
KnownTypeProvider.Register(genericType1.MakeGenericType(type));
}
}
}
static ServiceLayerComponentResolving()
{
IoC.Container = null;
KnownTypeProvider.ClearAllKnownTypes();
requestHandlerAssemblies = new List <Assembly> {
Assembly.GetExecutingAssembly(), typeof(RequestHandlerB).Assembly
};
requestResponseAssemblies = new List <Assembly> {
Assembly.GetExecutingAssembly(), typeof(RequestB).Assembly
};
configuration = new ServiceLayerConfiguration(requestHandlerAssemblies[0], requestResponseAssemblies[0],
Activator.CreateInstance <TContainer>());
configuration.AddRequestHandlerAssembly(requestHandlerAssemblies[1]);
configuration.AddRequestAndResponseAssembly(requestResponseAssemblies[1]);
configuration.Use <RequestHandlerBasedConventions>();
configuration.Initialize();
}
private void RegisterServices()
{
var genericsToApply = KnownTypeHelper.GetGenerics(typeof(Const).Assembly);
KnownTypeHelper.RegisterNonGenericRequestsAndResponses(typeof(PatientModule).Assembly);
KnownTypeHelper.RegisterGenerics(genericsToApply, typeof(PatientModule).Assembly);
KnownTypeHelper.RegisterKnownTypesFromIKnownTypeProviders(typeof(PatientModule).Assembly);
KnownTypeProvider.RegisterDerivedTypesOf <AbstractDataTransferObject>(typeof(PatientModule).Assembly.GetTypes().Where(t => !t.IsGenericType));
_container.RegisterType <ITerminologyProxy, TerminologyProxy> ();
_container.RegisterType <ICdsAlertService, CdsAlertService> ();
_container.RegisterType <IPatientAccessService, PatientAccessService> ();
_accessControlManager.RegisterPermissionDescriptor(
new ClientPermissionDescriptor());
_metadataService.LoadMetadataForModule(this);
}
/// <summary>
/// Configures agatha.
/// </summary>
/// <param name="appContainer">The app container.</param>
protected virtual void ConfigureAgatha(IContainer appContainer)
{
var structureMapContainer = new Agatha.StructureMap.Container(appContainer);
Agatha.Common.InversionOfControl.IoC.Container = structureMapContainer;
var assemblyLocator = appContainer.GetInstance <IAssemblyLocator> ();
var infrastructureAssemblies = assemblyLocator.LocateInfrastructureAssemblies();
var genericsToApply = new Dictionary <Type, Type> ();
foreach (var infrastructureAssembly in infrastructureAssemblies)
{
var genericsToApplyInAssebmly = KnownTypeHelper.GetGenerics(infrastructureAssembly);
foreach (var keyValuePair in genericsToApplyInAssebmly)
{
genericsToApply.Add(keyValuePair.Key, keyValuePair.Value);
}
}
var serviceAssemblies = assemblyLocator.LocateWebServiceAssemblies();
foreach (var assembly in serviceAssemblies)
{
KnownTypeHelper.RegisterNonGenericRequestsAndResponses(assembly);
KnownTypeProvider.RegisterDerivedTypesOf <AbstractDataTransferObject> (assembly.GetTypes().Where(t => !t.IsGenericType));
KnownTypeHelper.RegisterGenerics(genericsToApply, assembly);
}
var clientConfiguration = new ClientConfiguration(structureMapContainer)
{
AsyncRequestDispatcherImplementation = typeof(AsyncRequestDispatcher)
};
clientConfiguration.AddRequestAndResponseAssembly(typeof(GetLookupValuesRequest).Assembly);
clientConfiguration.RequestProcessorImplementation = typeof(CustomSyncRequestProcessorProxy);
clientConfiguration.Initialize();
}
// TODO - Would be "more than nice" to have a test harness on this class
public static ResultBase DeserialiseResultBase(string json)
{
var regexId = new Regex("__type\\\":\\\"(?<one>[^:]*):#(?<two>[^\\\"]*)\"");
var matchId = regexId.Match(json);
if (!matchId.Success)
{
throw new FormatException("Failed to decoded result - missing __type field");
}
var className = matchId.Groups[1].Value;
var assemblyName = matchId.Groups[2].Value;
var type = Type.GetType(assemblyName + "." + className);
var dcs = new DataContractJsonSerializer(type, KnownTypeProvider.GetKnownTypesFor(typeof(ResultBase)));
var textStream = new MemoryStream(UTF8Encoding.Default.GetBytes(json));
return((ResultBase)dcs.ReadObject(textStream));
}
public IEnumerable <Type> GetRegisteredRequestTypes()
{
return(KnownTypeProvider.GetKnownTypes(null));
}
static PhoneAutomationService()
{
KnownTypeProvider.RegisterDerivedTypesOf <CommandBase>(typeof(CommandBase).Assembly);
KnownTypeProvider.RegisterDerivedTypesOf <ResultBase>(typeof(ResultBase).Assembly);
}
public void ResponseTypeIsRegistered()
{
Assert.Contains(typeof(ResponseA), KnownTypeProvider.GetKnownTypes(null));
}
public void ResponseTypeFromExtraAssemblyIsRegistered()
{
Assert.Contains(typeof(ResponseB), KnownTypeProvider.GetKnownTypes(null));
}
public RestRequestBuilderTests()
{
KnownTypeProvider.Register(typeof(TRequestType1));
KnownTypeProvider.Register(typeof(TRequestType2));
}
