public void RegisterPackage(IDependencyCollection collection)
{
collection.LoadPackage(new XPike.Caching.Package());
collection.LoadPackage(new XPike.Redis.Package());
collection.RegisterSingleton <IRedisCachingConnectionProvider, RedisCachingConnectionProvider>();
}
public DeserializationResult Read(ISerializationManager serializationManager, ValueDataNode node,
IDependencyCollection dependencies,
bool skipHook,
ISerializationContext?context = null)
{
return(new DeserializedValue <Regex>(new Regex(node.Value, RegexOptions.Compiled)));
}
public ValidationNode Validate(ISerializationManager serializationManager, ValueDataNode node,
IDependencyCollection dependencies, ISerializationContext?context = null)
{
return(ushort.TryParse(node.Value, out _)
? new ValidatedValueNode(node)
: new ErrorNode(node, $"Failed parsing unsigned short value: {node.Value}"));
}
DeserializationResult ITypeReader <SpriteSpecifier, MappingDataNode> .Read(
ISerializationManager serializationManager, MappingDataNode node,
IDependencyCollection dependencies,
bool skipHook, ISerializationContext?context)
{
return(((ITypeReader <Rsi, MappingDataNode>) this).Read(serializationManager, node, dependencies, skipHook, context));
}
public DeserializationResult Read(ISerializationManager serializationManager, ValueDataNode node,
IDependencyCollection dependencies, bool skipHook, ISerializationContext?context = null)
{
var constType = serializationManager.GetConstantTypeFromTag(typeof(TTag));
return(new DeserializedValue((int)Enum.Parse(constType, node.Value)));
}
ValidationNode ITypeValidator <Texture, ValueDataNode> .Validate(ISerializationManager serializationManager,
ValueDataNode node,
IDependencyCollection dependencies,
ISerializationContext?context)
{
return(serializationManager.ValidateNode(typeof(ResourcePath), new ValueDataNode($"{SharedSpriteComponent.TextureRoot / node.Value}"), context));
}
ValidationNode ITypeValidator <Rsi, MappingDataNode> .Validate(ISerializationManager serializationManager,
MappingDataNode node,
IDependencyCollection dependencies,
ISerializationContext?context)
{
if (!node.TryGet("sprite", out var pathNode) || pathNode is not ValueDataNode valuePathNode)
{
return(new ErrorNode(node, "Missing/Invalid sprite node"));
}
if (!node.TryGet("state", out var stateNode) || stateNode is not ValueDataNode)
{
return(new ErrorNode(node, "Missing/Invalid state node"));
}
var path = serializationManager.ValidateNode(typeof(ResourcePath),
new ValueDataNode($"{SharedSpriteComponent.TextureRoot / valuePathNode.Value}"), context);
if (path is ErrorNode)
{
return(path);
}
return(new ValidatedValueNode(node));
}
/// <summary>
/// Registers XPike.RequestContext.Http.WebApi with the DI provider.
/// </summary>
/// <param name="dependencyCollection">The IDependencyCollection to register with.</param>
public void RegisterPackage(IDependencyCollection dependencyCollection)
{
/* Load the XPike.RequestContext.Http package which we depend on */
dependencyCollection.LoadPackage(new XPike.RequestContext.Http.Package());
dependencyCollection.RegisterSingleton <IHttpRequestContextProvider, WebApiRequestContextProvider>();
}
/// <summary>
/// Registers XPike.Configuration with the DI container with a custom-built IConfigurationService.
/// Uses an optional IDictionary to obtain default configuration values.
///
/// The collection of configuration providers registered with the DI container will not be used.
/// </summary>
/// <param name="dependencyCollection"></param>
/// <param name="providerSetup"></param>
/// <param name="staticConfig"></param>
/// <returns></returns>
public static IDependencyCollection AddXPikeConfiguration(this IDependencyCollection dependencyCollection, Action <IXPikeConfigBuilder> providerSetup)
{
dependencyCollection.AddXPikeConfiguration()
.RegisterSingleton(new XPikeConfigBuilder(providerSetup).Build());
return(dependencyCollection);
}
public void RegisterPackage(IDependencyCollection dependencyCollection)
{
// NOTE: No need to load the IoC package. This is a responsibility of the IoC Provider.
dependencyCollection.RegisterSingleton <IEnvironmentConfigurationProvider, EnvironmentConfigurationProvider>();
dependencyCollection.RegisterSingleton <INullConfigurationProvider, NullConfigurationProvider>();
// NOTE: This is not valid, because MemoryConfigurationProvider's constructor expects a Dictionary<string, string>.
// dependencyCollection.RegisterSingleton<IMemoryConfigurationProvider, MemoryConfigurationProvider>();
// NOTE: But this is valid:
//dependencyCollection.RegisterSingleton<IMemoryConfigurationProvider>(provider => new MemoryConfigurationProvider(new Dictionary<string, string>
//{
// {"key", "value"}
//}));
if (_configuration != null)
{
dependencyCollection.RegisterSingleton <IMemoryConfigurationProvider>(new MemoryConfigurationProvider(_configuration));
dependencyCollection.AddSingletonToCollection <IConfigurationProvider, IMemoryConfigurationProvider>(provider => provider.ResolveDependency <IMemoryConfigurationProvider>());
}
dependencyCollection.AddSingletonToCollection <IConfigurationProvider, IEnvironmentConfigurationProvider>((provider) => {
return(provider.ResolveDependency <IEnvironmentConfigurationProvider>());
});
dependencyCollection.RegisterSingleton <IConfigurationService, ConfigurationService>();
dependencyCollection.RegisterSingleton(typeof(IConfigManager <>), typeof(DefaultConfigManager <>));
dependencyCollection.RegisterSingleton(typeof(IConfig <>), typeof(ConfigLoader <>));
}
public void RegisterPackage(IDependencyCollection dependencyCollection)
{
dependencyCollection.LoadPackage(new XPike.Configuration.Package());
dependencyCollection.RegisterSingleton <IAzureConfigurationProvider>(new AzureConfigurationProvider(_connectionString));
dependencyCollection.AddSingletonToCollection <IConfigurationProvider, IAzureConfigurationProvider>(provider => provider.ResolveDependency <IAzureConfigurationProvider>());
}
/// <summary>
/// Adds Microsoft Extensions Configuration as the only provider for XPike Configuration after removing any previous registrations.
/// Uses an optional IDictionary to retrieve default configuration values.
/// Obtains XPike Configuration Providers from the DI container.
/// If no IConfiguration is specified, this will also be retrieved from the DI container.
/// </summary>
/// <param name="collection"></param>
/// <param name="staticConfig"></param>
/// <param name="configuration"></param>
/// <returns></returns>
public static IDependencyCollection UseMicrosoftConfigurationForXPike(this IDependencyCollection collection,
IDictionary <string, string> staticConfig = null,
IConfiguration configuration = null)
{
collection.ResetCollection <IConfigurationProvider>();
return(collection.AddXPikeMicrosoftConfiguration(staticConfig, configuration));
}
/// <summary>
/// Adds Microsoft Extensions Configuration as a provider for XPike Configuration.
/// Uses an optional IDictionary to retrieve default configuration values.
/// Obtains XPike Configuration Providers from the DI container.
/// If no IConfiguration is specified, this will also be retrieved from the DI container.
/// </summary>
/// <param name="collection"></param>
/// <param name="staticConfig"></param>
/// <param name="configuration"></param>
/// <returns></returns>
public static IDependencyCollection AddXPikeMicrosoftConfiguration(this IDependencyCollection collection,
IDictionary <string, string> staticConfig = null,
IConfiguration configuration = null)
{
collection.LoadPackage(new XPike.Configuration.Microsoft.Package(configuration, staticConfig));
return(collection);
}
public void RegisterPackage(IDependencyCollection dependencyCollection)
{
dependencyCollection.LoadPackage(new XPike.DataStores.Package());
dependencyCollection.LoadPackage(new XPike.MultiTenant.Package());
dependencyCollection.RegisterSingleton <IMultiTenantConnectionStringManager, MultiTenantConnectionStringManager>();
}
protected internal override void InternalRegisterDependencies(IDependencyCollection dependencies)
{
if (m_address.OffsetElement != null)
{
dependencies.Add(m_address.OffsetElement);
}
}
public IDependencyCollection Register(IDependencyCollection services)
{
// member
services.AddScoped <IUmbracoMemberCreatedEventService, MemberEventService>();
services.AddScoped <IUmbracoMemberAssignedRolesEventService, MemberEventService>();
services.AddScoped <IUmbracoMemberRemovedRolesEventService, MemberEventService>();
services.AddScoped <IUmbracoMemberDeletingEventService, MemberEventService>();
services.AddScoped <IUmbracoMemberGroupDeletingEventService, MemberGroupEventService>();
services.AddScoped <IUmbracoMemberGroupSavedEventService, MemberGroupEventService>();
// media
services.AddScoped <IUmbracoMediaSavedEventService, VideoConvertEventService>();
//services.AddScoped<IUmbracoMediaTrashedEventService, SearchMediaEventService>();
//services.AddScoped<IUmbracoMediaSavedEventService, SearchMediaEventService>();
//services.AddScoped<IUmbracoMediaSavingEventService, SearchMediaEventService>();
//content
services.AddScopedToCollection <IUmbracoContentTrashedEventService, ArticlePageEventService>();
services.AddScopedToCollection <IUmbracoContentPublishedEventService, ArticlePageEventService>();
services.AddScopedToCollection <IUmbracoContentUnPublishedEventService, ArticlePageEventService>();
//user tags
services.AddScopedToCollection <IUmbracoContentTrashedEventService, UserTagsEventService>();
services.AddScopedToCollection <IUmbracoContentPublishedEventService, UserTagsEventService>();
services.AddScopedToCollection <IUmbracoContentUnPublishedEventService, UserTagsEventService>();
return(services);
}
public DeserializationResult Read(ISerializationManager serializationManager, MappingDataNode node,
IDependencyCollection dependencies,
bool skipHook,
ISerializationContext?context = null)
{
if (!node.TryGet("type", out var typeNode))
{
throw new InvalidMappingException("No type specified for AppearanceVisualizer!");
}
if (typeNode is not ValueDataNode typeValueDataNode)
{
throw new InvalidMappingException("Type node not a value node for AppearanceVisualizer!");
}
var type = IoCManager.Resolve <IReflectionManager>()
.YamlTypeTagLookup(typeof(AppearanceVisualizer), typeValueDataNode.Value);
if (type == null)
{
throw new InvalidMappingException(
$"Invalid type {typeValueDataNode.Value} specified for AppearanceVisualizer!");
}
var newNode = (MappingDataNode)node.Copy();
newNode.Remove("type");
return(serializationManager.Read(type, newNode, context, skipHook));
}
public static void AddScoped <TDefinition, TImplementation>(this IDependencyCollection collection, Binding binding = Binding.Bound) where TImplementation : TDefinition
{
collection.Register <TImplementation>()
.DefineAs <TDefinition>()
.AsScoped()
.SetBinding(binding);
}
ValidationNode ITypeValidator <SpriteSpecifier, MappingDataNode> .Validate(
ISerializationManager serializationManager, MappingDataNode node,
IDependencyCollection dependencies,
ISerializationContext?context)
{
return(((ITypeReader <Rsi, MappingDataNode>) this).Validate(serializationManager, node, dependencies, context));
}
public static void AddSingleton <TDefinition, TImplementation>(this IDependencyCollection collection, Func <TImplementation> builder, Binding binding = Binding.Bound) where TImplementation : TDefinition
{
collection.Register(builder)
.DefineAs <TDefinition>()
.AsSingleton()
.SetBinding(binding);
}
DeserializationResult ITypeReader <EntityPrototype, ValueDataNode> .Read(
ISerializationManager serializationManager, ValueDataNode node,
IDependencyCollection dependencies,
bool skipHook, ISerializationContext?context)
{
return(new DeserializedValue <EntityPrototype>(new EntityPrototype(node.Value)));
}
public static void AddTransient <TDefinition, TImplementation>(this IDependencyCollection collection, Func <IDependencyProvider, TImplementation> builder, Binding binding = Binding.Bound) where TImplementation : TDefinition
{
collection.Register(builder)
.DefineAs <TDefinition>()
.AsTransient()
.SetBinding(binding);
}
public ValidationNode Validate(ISerializationManager serializationManager, ValueDataNode node,
IDependencyCollection dependencies, ISerializationContext?context = null)
{
var constType = serializationManager.GetConstantTypeFromTag(typeof(TTag));
return(Enum.TryParse(constType, node.Value, out _) ? new ValidatedValueNode(node) : new ErrorNode(node, "Failed parsing constant.", false));
}
DeserializationResult ITypeReader <IReadOnlyList <string>, SequenceDataNode> .Read(
ISerializationManager serializationManager,
SequenceDataNode node,
IDependencyCollection dependencies,
bool skipHook,
ISerializationContext?context)
{
var list = new List <string>();
var mappings = new List <DeserializationResult>();
foreach (var dataNode in node.Sequence)
{
var result = _prototypeSerializer.Read(
serializationManager,
(ValueDataNode)dataNode,
dependencies,
skipHook,
context);
list.Add((string)result.RawValue !);
mappings.Add(result);
}
return(new DeserializedCollection <IReadOnlyList <string>, string>(list, mappings,
elements => new List <string>(elements)));
}
public ValidationNode Validate(ISerializationManager serializationManager, ValueDataNode node,
IDependencyCollection dependencies,
ISerializationContext?context = null)
{
var path = new ResourcePath(node.Value);
if (path.Extension.Equals("rsi"))
{
path /= "meta.json";
}
if (!path.EnumerateSegments().First().Equals("Textures", StringComparison.InvariantCultureIgnoreCase))
{
path = SharedSpriteComponent.TextureRoot / path;
}
path = path.ToRootedPath();
try
{
return(IoCManager.Resolve <IResourceManager>().ContentFileExists(path)
? new ValidatedValueNode(node)
: new ErrorNode(node, $"File not found. ({path})"));
}
catch (Exception e)
{
return(new ErrorNode(node, $"Failed parsing filepath. ({path}) ({e.Message})"));
}
}
public ValidationNode Validate(ISerializationManager serializationManager, ValueDataNode node,
IDependencyCollection dependencies, ISerializationContext?context = null)
{
return(dependencies.Resolve <IPrototypeManager>().HasIndex <TPrototype>(node.Value)
? new ValidatedValueNode(node)
: new ErrorNode(node, $"PrototypeID {node.Value} for type {typeof(TPrototype)} not found"));
}
public DeserializationResult Read(ISerializationManager serializationManager, ValueDataNode node,
IDependencyCollection dependencies,
bool skipHook,
ISerializationContext?context = null)
{
return(new DeserializedValue <string>(node.Value));
}
public static void BindHeatMapServices(this IDependencyCollection dc, IServicesSettings settings)
{
var bidAskRepository = new BidAskRepository(new MyNoSqlServerClient <BidAskMySqlTableEntity>(settings.CacheUrl, "bidask"));
dc.AddSingleton <IBidAskRepository, BidAskRepository>(bidAskRepository);
var bidAskHistoryRepository = new BidAskHistoryRepository(new MyNoSqlServerClient <BidAskHistoryTableEntity>(settings.CacheUrl, "bidaskhistory"));
dc.AddSingleton <IBidAskHistoryRepository, BidAskHistoryRepository>(bidAskHistoryRepository);
var bidAskCache = new BidAskCache(bidAskRepository);
dc.AddSingleton <IBidAskCache, BidAskCache>(bidAskCache);
var indexInfoRepo = new IndexInformationRepository(new MyNoSqlServerClient <IndexInformationTableEntity>(settings.CacheUrl, "indexinfo"));
dc.AddSingleton <IIndexInformationRepository, IndexInformationRepository>(indexInfoRepo);
var overshootInfoRepo = new OvershootIndicatorsDataRepository(new MyNoSqlServerClient <OvershootIndicatorNoSqlEntity>(settings.CacheUrl, "overshoots"));
dc.AddSingleton <IOvershootIndicatorsDataRepository, OvershootIndicatorsDataRepository>(overshootInfoRepo);
TimerExecutor = new TimerExecutor(1000)
.RegisterTimer(nameof(bidAskCache), bidAskCache);
TimerExecutor.Start();
}
public DeserializationResult Read(ISerializationManager serializationManager, MappingDataNode node,
IDependencyCollection dependencies, bool skipHook, ISerializationContext?context = null)
{
var type = GetType(node);
return(serializationManager.Read(type, node, context, skipHook));
}
public ValidationNode Validate(ISerializationManager serializationManager, ValueDataNode node,
IDependencyCollection dependencies, ISerializationContext?context = null)
{
return(float.TryParse(node.Value, NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, out _)
? new ValidatedValueNode(node)
: new ErrorNode(node, $"Failed parsing float value: {node.Value}"));
}
