public static Assembly[] MapConventionsForAssemblies(Type[] viewAssemblyRootAnchors, Type[] viewModelAssemblyRootAnchors)
{
if (viewAssemblyRootAnchors == null) throw new ArgumentNullException("viewAssemblyRootAnchors");
if (viewAssemblyRootAnchors.Any(type => type == null))
throw new ArgumentException("viewAssemblyRootAnchors contains null elements");
if (viewModelAssemblyRootAnchors == null) throw new ArgumentNullException("viewModelAssemblyRootAnchors");
if (viewModelAssemblyRootAnchors.Any(type => type == null))
throw new ArgumentException("viewModelAssemblyRootAnchors contains null elements");
foreach (var viewAssemblyRootAnchor in viewAssemblyRootAnchors)
{
foreach (var viewModelAssemblyRootAnchor in viewModelAssemblyRootAnchors)
{
//{
// var vmNs = viewModelAssemblyRootAnchor.Namespace + ".ViewModels";
// var vNs = viewAssemblyRootAnchor.Namespace + ".Views";
// ViewLocator.AddNamespaceMapping(vmNs, vNs);
// ViewModelLocator.AddNamespaceMapping(vNs, vmNs);
//}
{
var vmNs = viewModelAssemblyRootAnchor.Namespace + ".ViewModels";
var vNs = viewAssemblyRootAnchor.Namespace + ".Views";
ViewLocator.AddSubNamespaceMapping(vmNs, vNs);
ViewModelLocator.AddSubNamespaceMapping(vNs, vmNs);
}
}
}
return
viewAssemblyRootAnchors.Concat(viewModelAssemblyRootAnchors)
.Select(type => type.Assembly)
.Distinct()
.ToArray();
}
private static Type GetDelegateType(Type returnType, Type[] args)
{
if (returnType == null || returnType == typeof(void))
{
return Type.GetType("System.Action`" + args.Length).MakeGenericType(args);
}
else
{
return Type.GetType("System.Func`" + (args.Length + 1)).MakeGenericType(args.Concat(new[] { returnType }).ToArray());
}
}
static Serializer()
{
var dataTypes = new Type[] { typeof(IntGrid2), typeof(IntGrid2Z) };
var messageTypes = Helpers.GetSubclasses(typeof(Message));
var objectDataTypes = Helpers.GetSubclasses(typeof(BaseGameObjectData));
var changeTypes = Helpers.GetSubclasses(typeof(ChangeData));
var actionTypes = Helpers.GetSubclasses(typeof(GameAction));
var events = Helpers.GetSubclasses(typeof(GameEvent));
var extra = new Type[] { typeof(GameColor), typeof(LivingGender), typeof(GameSeason) };
var reports = Helpers.GetSubclasses(typeof(GameReport));
var tileDataEnums = typeof(TileData).GetFields().Select(fi => fi.FieldType);
var types = dataTypes.Concat(messageTypes).Concat(objectDataTypes).Concat(changeTypes).Concat(actionTypes).Concat(events)
.Concat(extra).Concat(reports).Concat(tileDataEnums);
s_serializer = new NetSerializer.Serializer(types.ToArray());
}
private Type GetFuncType(Type[] typeArgs, Type resultType)
{
if (typeArgs.Length >= actionTypes.Length)
{
throw errorProvider.GetTooManyBindingParamError(actionTypes.Length - 1);
}
if (typeArgs.Length == 0)
{
return funcTypes[0].MakeGenericType(resultType);
}
var genericTypeArgs = typeArgs.Concat(new Type[] {resultType}).ToArray();
return funcTypes[typeArgs.Length].MakeGenericType(genericTypeArgs);
}
/// <summary>
/// Core WCA services. Registeres WCA Core dependencies.
/// </summary>
/// <param name="services"></param>
/// <returns></returns>
public static IServiceCollection AddWCACore(this IServiceCollection services, Action <WCACoreOptions> setupAction)
{
if (setupAction == null)
{
throw new ArgumentNullException(nameof(setupAction), "A setup action is required to supply a valid IConfiguration object.");
}
var wcaCoreOptions = new WCACoreOptions();
setupAction(wcaCoreOptions);
if (wcaCoreOptions.Configuration == null)
{
throw new ArgumentNullException(
nameof(setupAction),
"A setup action was supplied, however the Configuration property was null. " +
"A value must be supplied for the Configuration property.");
}
var wcaCoreConfiguration = wcaCoreOptions.Configuration.GetSection("WCACoreSettings");
services.Configure <WCACoreSettings>(wcaCoreConfiguration);
var coreSettings = wcaCoreConfiguration.Get <WCACoreSettings>();
services.Configure <GlobalXOptions>(wcaCoreOptions.Configuration.GetSection("WCACoreSettings:GlobalXOptions"));
JsonConvert.DefaultSettings = () =>
{
var jsonSerializerSettings = new JsonSerializerSettings();
jsonSerializerSettings.ConfigureForNodaTime(DateTimeZoneProviders.Tzdb);
return(jsonSerializerSettings);
};
services.AddMemoryCache();
services.AddSingleton <IEmailSender, SendGridEmailSender>();
services.AddSingleton <ISupportSystem, FreshDeskSupportSystem>();
services.AddSingleton <IDurableFunctionsService, DurableFunctionsService>();
AddFreshDesk(services, coreSettings.FreshDeskSettings);
#pragma warning disable CA2000 // Dispose objects before losing scope. Added as Singleton so will exist for lifetime of app.
services.AddSingleton <IEventStore>(sp =>
{
// Event store configuration
var eventStoreBuilder = Wireup.Init()
.UsingSqlPersistence(SqlClientFactory.Instance, wcaCoreOptions.Configuration.GetConnectionString("DefaultConnection"))
.WithDialect(new MsSqlDialect())
.InitializeStorageEngine()
.UsingCustomSerialization(new NEventStoreJsonSerializer())
.Compress();
if (wcaCoreOptions.IsDevelopment)
{
eventStoreBuilder.LogTo((typeToLog) => new NEventStoreTelemetryLoggerAdapter(sp.GetService <IOptions <TelemetryConfiguration> >(), typeToLog, NEventStore.Logging.LogLevel.Verbose));
eventStoreBuilder.LogToConsoleWindow();
}
else
{
eventStoreBuilder.LogTo((typeToLog) => new NEventStoreTelemetryLoggerAdapter(sp.GetService <IOptions <TelemetryConfiguration> >(), typeToLog, NEventStore.Logging.LogLevel.Info));
}
return(new NEventStoreImplementation(eventStoreBuilder.Build()));
});
#pragma warning restore CA2000 // Dispose objects before losing scope
services.AddSingleton <IEventSourcedAggregateRepository <ActionstepMatter>, AggregateRepository <ActionstepMatter> >();
services.AddSingleton <IActionstepToWCAMapper>(new ActionstepToWCAMapper());
// AutoMapper
var autoMapperProfileTypes = new Type[] { typeof(CommandProfile) };
if (wcaCoreOptions.AutoMapperProfileAssemblyMarkerTypes == null)
{
services.AddAutoMapper(autoMapperProfileTypes);
}
else
{
services.AddAutoMapper(
autoMapperProfileTypes.Concat(
wcaCoreOptions.AutoMapperProfileAssemblyMarkerTypes).ToArray());
}
services.AddWCAData(
wcaCoreOptions.Configuration.GetConnectionString("DefaultConnection"));
services.AddTransient <ITelemetryLogger, AppInsightsTelemetryLogger>();
Assembly wcaCoreAssembly = typeof(ServiceCollectionExtensions).GetTypeInfo().Assembly;
var allValidatorTypes = wcaCoreAssembly
.GetTypes()
.Where(t => typeof(IValidator).IsAssignableFrom(t));
foreach (var validatorType in allValidatorTypes)
{
services.AddSingleton(validatorType);
}
services.AddMediatR(wcaCoreAssembly);
services.AddTransient <ITokenSetRepository, TokenSetRepository>();
services.AddTransient <IGlobalXApiTokenRepository, GlobalXApiTokenRepository>();
services.AddTransient <IGlobalXCredentialsRepository, GlobalXCredentialsRepository>();
services.AddTransient <IFirstTitleCredentialRepository, FirstTitleCredentialRepository>();
services.AddSingleton <IClock>(SystemClock.Instance);
services.AddSingleton <IInfoTrackCredentialRepository, InfoTrackCredentialRepository>();
// Using IHttpClientFactory typed approach which is new in netcoreapp2.1 as per
// https://github.com/aspnet/HttpClientFactory/wiki/Consumption-Patterns
var productInfoHeaderValue = new ProductInfoHeaderValue("WorkCloudApplicationsAutomation", "1.0");
services.AddTransient <HttpClientAppInsightsHandler>();
services.AddHttpClient();
// For more info on Polly and retry policies
// See https://github.com/App-vNext/Polly/wiki/Polly-and-HttpClientFactory#using-addtransienthttperrorpolicy
var defaultSleepDurations = new[]
{
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(5),
TimeSpan.FromSeconds(10)
};
services.AddHttpClient <IGlobalXService, GlobalXService>()
.AddTransientHttpErrorPolicy(builder => builder.WaitAndRetryAsync(defaultSleepDurations))
.AddHttpMessageHandler <HttpClientAppInsightsHandler>();
services.AddHttpClient <IExtendedPexaService, ExtendedPexaService>()
.AddTransientHttpErrorPolicy(builder => builder.WaitAndRetryAsync(defaultSleepDurations))
.AddHttpMessageHandler <HttpClientAppInsightsHandler>();
services.AddActionstepService(
productInfoHeaderValue,
options =>
{
options.ClientId = coreSettings.ActionstepSettings.ApiClientId;
options.ClientSecret = coreSettings.ActionstepSettings.ApiClientSecret;
options.ActionstepEnvironment = coreSettings.ActionstepSettings.ActionstepEnvironment;
})
.AddTransientHttpErrorPolicy(builder => builder.WaitAndRetryAsync(defaultSleepDurations))
.AddHttpMessageHandler <HttpClientAppInsightsHandler>();
services.AddHttpClient <InfoTrackService>(c =>
{
c.DefaultRequestHeaders.UserAgent.Add(productInfoHeaderValue);
})
.AddTransientHttpErrorPolicy(builder => builder.WaitAndRetryAsync(defaultSleepDurations))
.AddHttpMessageHandler <HttpClientAppInsightsHandler>();
services.AddSingleton <IFirstTitleToWCAMapper>(new FirstTitleToWCAMapper());
services.AddSingleton <IWCAToFirstTitleMapper>(new WCAToFirstTitleMapper());
services.AddHttpClient <IFirstTitleClient, FirstTitleClient>()
.AddTransientHttpErrorPolicy(builder => builder.WaitAndRetryAsync(defaultSleepDurations))
.AddHttpMessageHandler <HttpClientAppInsightsHandler>();
return(services);
}
protected MethodInfo GetInterfaceMethod(Type interfaceType, MethodInfo classMethod)
{
var reflectedType = classMethod.ReflectedType;
var it = new Type[] { interfaceType };
var interfaces = it.Concat(interfaceType.GetInterfaces());
foreach (var type in interfaces)
{
var interfaceMap = reflectedType.GetInterfaceMap(type);
var index = Array.IndexOf(interfaceMap.TargetMethods, classMethod);
if (index != -1)
return interfaceMap.InterfaceMethods[index];
}
return null;
}
private static void EmitSetter(TypeBuilder proxyTypeBuilder, PropertyBuilder propertyBuilder, FieldBuilder self, PropertyInfo declaration, PropertyInfo delegatedProperty, Type propertyType, Type[] indexTypes)
{
var setter = declaration.GetSetMethod();
if (setter != null)
{
indexTypes = indexTypes.Concat(propertyType.AsSingleEnumerable()).ToArray();
var setterBuilder = proxyTypeBuilder.DefineMethod("set_" + declaration.Name, PropertyAttribute, null, indexTypes);
var generator = setterBuilder.GetILGenerator();
if (delegatedProperty == null)
{
generator.ThrowException(typeof(NotSupportedException));
}
else
{
var delegatedSetter = delegatedProperty.GetSetMethod();
EmitImplementation(generator, self, delegatedSetter, indexTypes);
propertyBuilder.SetSetMethod(setterBuilder);
}
}
}
