public TextMessageWorkerService(
IConfiguration config,
IRabbitService rabbitService,
ISerializationProvider serializationProvider,
ILogger <TextMessageWorkerService> logger = null)
{
Guard.AgainstNull(config, nameof(config));
Guard.AgainstNull(rabbitService, nameof(rabbitService));
Guard.AgainstNull(rabbitService, nameof(rabbitService));
Guard.AgainstNull(serializationProvider, nameof(serializationProvider));
_logger = logger;
_config = config;
_rabbitService = rabbitService;
_serializationProvider = serializationProvider;
_consumerName = _config.GetSection("HouseofCat:NotificationService:ConsumerName").Get <string>();
_options = _rabbitService.Options.GetConsumerOptions(_consumerName);
_from = _config.GetSection("HouseofCat:NotificationService:From").Get <string>();
_account = _config.GetSection("HouseofCat:NotificationService:Account").Get <string>();
_token = _config.GetSection("HouseofCat:NotificationService:Token").Get <string>();
TwilioClient.Init(_account, _token);
}
private static async Task SetupAsync()
{
var letterTemplate = new Letter("", "TestRabbitServiceQueue", null, new LetterMetadata());
var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole().SetMinimumLevel(LogLevel));
_logger = loggerFactory.CreateLogger <ConsumerDataflow <WorkState> >();
_hashingProvider = new Argon2ID_HashingProvider();
var hashKey = await _hashingProvider.GetHashKeyAsync("passwordforencryption", "saltforencryption", 32).ConfigureAwait(false);
_metricsProvider = new NullMetricsProvider();
_encryptionProvider = new AesGcmEncryptionProvider(hashKey);
_compressionProvider = new LZ4PickleProvider();
_serializationProvider = new Utf8JsonProvider();
_rabbitService = new RabbitService(
"Config.json",
_serializationProvider,
_encryptionProvider,
_compressionProvider,
loggerFactory);
await _rabbitService
.Topologer
.CreateQueueAsync("TestRabbitServiceQueue")
.ConfigureAwait(false);
}
public ConfigurationDetails(IPredicate predicate, ISerializationProvider serializationProvider, ISourceDataProvider sourceDataProvider, IEvaluator evaluator)
{
_predicate = predicate;
_serializationProvider = serializationProvider;
_sourceDataProvider = sourceDataProvider;
_evaluator = evaluator;
}
public QueueFactory(INamespaceManager <T> namespaceManager,
ISerializationProvider serializationProvider,
ILogger <ClientBase <T> > logger,
IEnumerable <IMessageExtension <T> > extensions)
{
if (namespaceManager == null)
{
throw new ArgumentNullException(nameof(namespaceManager));
}
if (serializationProvider == null)
{
throw new ArgumentNullException(nameof(serializationProvider));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (extensions == null)
{
throw new ArgumentNullException(nameof(extensions));
}
_namespaceManager = namespaceManager;
_serializationProvider = serializationProvider;
_logger = logger;
_extensions = extensions;
}
protected SerializablePropertyBase(string key, ISerializationProvider provider, T?defaultValue)
{
Key = key ?? throw new ArgumentNullException(nameof(key));
Provider = provider ?? throw new ArgumentNullException(nameof(provider));
Default = defaultValue;
Provider.Reloaded += (sender, args) =>
{
if (_cached)
{
_cached = false;
var oldValue = _value;
var newValue = Value;
if (!Equals(oldValue, newValue))
{
OnValueChanged(oldValue, newValue);
}
}
else
{
var oldValue = default(T);
var newValue = Value;
OnValueChanged(oldValue, newValue);
}
};
}
public PredicateRootPathResolver(IPredicate predicate, ISerializationProvider serializationProvider, ISourceDataProvider sourceDataProvider, ILogger logger)
{
_predicate = predicate;
_serializationProvider = serializationProvider;
_sourceDataProvider = sourceDataProvider;
_logger = logger;
}
public IconService(
ISerializationProvider serializationProvider,
ILogger logger)
{
_serializationProvider = Arguments.NotNull(serializationProvider, nameof(serializationProvider));
_logger = Arguments.NotNull(logger, nameof(logger));
}
public RabbitService(
Options options,
ISerializationProvider serializationProvider,
IEncryptionProvider encryptionProvider = null,
ICompressionProvider compressionProvider = null,
ILoggerFactory loggerFactory = null,
Func <PublishReceipt, ValueTask> processReceiptAsync = null)
{
Guard.AgainstNull(options, nameof(options));
Guard.AgainstNull(serializationProvider, nameof(serializationProvider));
LogHelper.LoggerFactory = loggerFactory;
Options = options;
ChannelPool = new ChannelPool(Options);
SerializationProvider = serializationProvider;
EncryptionProvider = encryptionProvider;
CompressionProvider = compressionProvider;
Publisher = new Publisher(ChannelPool, SerializationProvider, EncryptionProvider, CompressionProvider);
Topologer = new Topologer(ChannelPool);
Options.ApplyGlobalConsumerOptions();
BuildConsumers();
Publisher
.StartAutoPublishAsync(processReceiptAsync)
.GetAwaiter()
.GetResult();
BuildConsumerTopology()
.GetAwaiter()
.GetResult();
}
async UniTask Test <T>(T data, ISerializationProvider serializationProvider)
{
var serialized = await serializationProvider.SerializeAsync(data);
var deserialized = await serializationProvider.DeserializeAsync <T>(serialized);
Assert.AreEqual(data, deserialized);
}
public ProjectRepository(ISerializationProvider serializationProvider)
{
_serializationProvider = serializationProvider;
_path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetName().CodeBase);
_path = _path.Replace("file:\\", "");
}
public EmailWorkerService(
IConfiguration config,
ISerializationProvider serializationProvider,
IRabbitService rabbitService,
ILogger <EmailWorkerService> logger = null)
{
Guard.AgainstNull(config, nameof(config));
Guard.AgainstNull(rabbitService, nameof(rabbitService));
Guard.AgainstNull(serializationProvider, nameof(serializationProvider));
_config = config;
_serializationProvider = serializationProvider;
_rabbitService = rabbitService;
_logger = logger;
var mailKitOptions = new MailKitOptions
{
// Use Papercut Smtp for local testing!
// https://github.com/ChangemakerStudios/Papercut-SMTP/releases
Server = _config.GetValue <string>("HouseofCat:EmailService:SmtpHost"),
Port = _config.GetValue <int>("HouseofCat:EmailService:SmtpPort"),
SenderName = _config.GetValue <string>("HouseofCat:EmailService:SenderName"),
SenderEmail = _config.GetValue <string>("HouseofCat:EmailService:SenderEmail"),
//Account = Configuration.GetValue<string>("Email:Account"),
//Password = Configuration.GetValue<string>("Email:Password"),
//Security = Configuration.GetValue<bool>("Email:EnableTls")
};
var provider = new MailKitProvider(mailKitOptions);
_emailService = new EmailService(provider);
}
protected SalesSupportSystemWorkflowProvider(ISerializationProvider serializationProvider,
Subscriber localSubscriber,
ISalesSupportSystemDialogProvider dialogProvider)
:
base(dialogProvider)
{
Subscription subscription = new Subscription(localSubscriber);
this.ArticleInfoWorkflow = new ArticleInfoWorkflow(dialogProvider.ArticleInfoDialog, subscription);
this.ArticlePriceWorkflow = new ArticlePriceWorkflow(dialogProvider.ArticlePriceDialog, subscription);
this.ArticleSelectedWorkflow = new ArticleSelectedWorkflow(dialogProvider.ArticleSelectedDialog, subscription);
this.HelloWorkflow = new HelloWorkflow(dialogProvider.HelloDialog, subscription, dialogProvider, serializationProvider);
this.KeepAliveWorkflow = new KeepAliveWorkflow(dialogProvider.KeepAliveDialog, subscription);
this.ShoppingCartWorkflow = new ShoppingCartWorkflow(dialogProvider.ShoppingCartDialog, subscription);
this.ShoppingCartUpdateWorkflow = new ShoppingCartUpdateWorkflow(dialogProvider.ShoppingCartUpdateDialog, subscription);
this.UnprocessedWorkflow = new UnprocessedWorkflow(dialogProvider.UnprocessedDialog, subscription, serializationProvider);
this.ArticleInfoWorkflow.MessageProcessingError += this.OnMessageProcessingError;
this.ArticlePriceWorkflow.MessageProcessingError += this.OnMessageProcessingError;
this.ArticleSelectedWorkflow.MessageProcessingError += this.OnMessageProcessingError;
this.HelloWorkflow.MessageProcessingError += this.OnMessageProcessingError;
this.KeepAliveWorkflow.MessageProcessingError += this.OnMessageProcessingError;
this.ShoppingCartWorkflow.MessageProcessingError += this.OnMessageProcessingError;
this.ShoppingCartUpdateWorkflow.MessageProcessingError += this.OnMessageProcessingError;
this.UnprocessedWorkflow.MessageProcessingError += this.OnMessageProcessingError;
}
public PredicateRootPathResolver(IPredicate predicate, ISerializationProvider serializationProvider, ISourceDataProvider sourceDataProvider, ILogger logger)
{
_predicate = predicate;
_serializationProvider = serializationProvider;
_sourceDataProvider = sourceDataProvider;
_logger = logger;
}
public MessageSender(
IQueuePathProvider qPathProvider,
ISerializationProvider serializer)
{
_qPathProvider = qPathProvider;
_serializer = serializer;
}
public ConfigurationDetails(IPredicate predicate, ISerializationProvider serializationProvider, ISourceDataProvider sourceDataProvider, IEvaluator evaluator)
{
_predicate = predicate;
_serializationProvider = serializationProvider;
_sourceDataProvider = sourceDataProvider;
_evaluator = evaluator;
}
protected SerializablePropertyBase(string key, ISerializationProvider provider, [AllowNull] T defaultValue)
{
this.Key = key ?? throw new ArgumentNullException(nameof(key));
this.Provider = provider ?? throw new ArgumentNullException(nameof(provider));
this.Default = defaultValue;
this.Provider.Reloaded += (sender, args) =>
{
if (this._cached)
{
this._cached = false;
var oldValue = this._value;
var newValue = this.Value;
if (!Equals(oldValue, newValue))
{
this.OnValueChanged(oldValue, newValue);
}
}
else
{
var oldValue = default(T);
var newValue = this.Value;
this.OnValueChanged(oldValue, newValue);
}
};
}
/// <summary>
/// The DES protection provider
/// </summary>
public DesCryptoProvider(
ILogger <DesCryptoProvider> logger,
ISerializationProvider serializationProvider)
{
_logger = logger;
_serializationProvider = serializationProvider;
}
private Mock <HttpContext> BuildContext(string routePath, IService serviceInstance, Type requestDto = null,
string requestBody = "", Type responseDto = null, string routeTemplate = "",
string contentType = "application/json", string method = "GET",
Dictionary <string, object> routeValues = null, IQueryCollection query = null,
ISerializationProvider provider = null)
{
RestVerbs restMethods;
Enum.TryParse(method, true, out restMethods);
var route = new RouteAttribute(routePath, restMethods);
var context = new Mock <HttpContext>().SetupAllProperties();
var request = new Mock <HttpRequest>().SetupAllProperties();
var response = new Mock <HttpResponse>().SetupAllProperties();
var reqBody = new MemoryStream(Encoding.ASCII.GetBytes(requestBody));
var resBody = new MemoryStream();
var features = new Mock <IFeatureCollection>().SetupAllProperties();
var rserviceFeature = new RServiceFeature();
var routingFeature = new RoutingFeature();
var serializationProvider = provider ?? new NetJsonProvider();
features.Setup(x => x[typeof(IRServiceFeature)]).Returns(rserviceFeature);
features.Setup(x => x[typeof(IRoutingFeature)]).Returns(routingFeature);
rserviceFeature.RequestDtoType = requestDto;
rserviceFeature.ResponseDtoType = responseDto;
rserviceFeature.MethodActivator = _rservice.Routes[Utils.GetRouteKey(route, 0)].ServiceMethod;
rserviceFeature.Service = serviceInstance;
rserviceFeature.RequestSerializer = serializationProvider;
rserviceFeature.ResponseSerializer = serializationProvider;
if (!string.IsNullOrWhiteSpace(routeTemplate))
{
routingFeature.RouteData = new RouteData();
var constraints = new Mock <IInlineConstraintResolver>().SetupAllProperties();
var irouter = new Mock <IRouter>().SetupAllProperties();
var router = new Mock <Route>(irouter.Object, routeTemplate, constraints.Object)
.SetupAllProperties();
foreach (var kvp in routeValues ?? new Dictionary <string, object>())
{
routingFeature.RouteData.Values.Add(kvp.Key, kvp.Value);
}
routingFeature.RouteData.Routers.Add(null);
routingFeature.RouteData.Routers.Add(router.Object);
routingFeature.RouteData.Routers.Add(null);
}
request.Object.Method = method;
request.Object.ContentType = contentType;
request.Object.Body = reqBody;
request.Object.Query = query;
response.Object.Body = resBody;
context.SetupGet(x => x.Request).Returns(request.Object);
context.SetupGet(x => x.Response).Returns(response.Object);
context.SetupGet(x => x.Features).Returns(features.Object);
return(context);
}
public FileStorage(ISerializationProvider serializationProvider,
IFileProvider fileProvider)
{
_serializationProvider = serializationProvider ??
throw new ArgumentNullException(nameof(serializationProvider));
_fileProvider = fileProvider ??
throw new ArgumentNullException(nameof(fileProvider));
}
public void Storage_ThrowsArgumentNullException(
ISerializationProvider serializationProvider, IFileProvider fileProvider)
{
Assert.Throws <ArgumentNullException>(() =>
{
var storage = new FileStorage(serializationProvider, fileProvider);
});
}
public DataTransformSerializationProvider(ISerializationProvider baseProvider,
IDataTransform dataTransform)
{
_baseProvider = baseProvider ??
throw new ArgumentNullException(nameof(baseProvider));
_dataTransform = dataTransform ??
throw new ArgumentNullException(nameof(dataTransform));
}
public void SerializationProvider_ThrowsArgumentNullException(ISerializationProvider serializationProvider,
IDataTransform dataTransform)
{
Assert.Throws <ArgumentNullException>(() =>
{
var result = new DataTransformSerializationProvider(serializationProvider, dataTransform);
});
}
public JsonMessageStreamReader(Stream baseStream, ISerializationProvider serializationProvider, IInteractionLog interactionLog)
:
base(baseStream,
new JsonTokenizer(baseStream, interactionLog),
interactionLog)
{
this.MessageParser = new JsonMessageParser(serializationProvider);
}
public NamedPipeChannel(IDictionary properties, ISerializationProvider serialization = null)
: base(properties, serialization)
{
ChannelPriority = 1;
EnableAutomaticConnection = true;
ReconnectionInterval = 1000;
ChannelName = typeof(TService).Name;
}
public PwnedRecurrentTask(
ILogger logger,
IDataManager dataManager,
ISerializationProvider serializationProvider)
{
_logger = Arguments.NotNull(logger, nameof(logger));
_dataManager = Arguments.NotNull(dataManager, nameof(dataManager));
_serializationProvider = Arguments.NotNull(serializationProvider, nameof(serializationProvider));
}
protected Serializer(ISerializationProvider <TFormat> serializationProvider)
{
if (serializationProvider == null)
{
throw new ArgumentNullException(nameof(serializationProvider));
}
SerializationProvider = serializationProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="MockRepository" /> class.
/// </summary>
/// <param name="unitOfWork">The unit of work.</param>
/// <param name="serializationProvider">The serialization provider.</param>
/// <param name="seedData">The seed data.</param>
public MockRepository(MockUnitOfWork unitOfWork, ISerializationProvider serializationProvider, IEnumerable <IEntity> seedData)
: this()
{
this.UnitOfWork = unitOfWork;
this.UnitOfWork.AddRepository(this);
this._data = seedData.ToList();
this._initialData = serializationProvider.SerializeObject(seedData);
this._serializationProvider = serializationProvider;
}
public LicenseKeyDataProvider(
ISerializationProvider serializationProvider,
IWindowManager windowManager,
ILogger logger)
{
_serializationProvider = Arguments.NotNull(serializationProvider, nameof(serializationProvider));
_windowManager = Arguments.NotNull(windowManager, nameof(windowManager));
_logger = Arguments.NotNull(logger, nameof(logger));
}
public WiFiCredentialDataViewModel(
WiFiCredentialData accountData,
ISerializationProvider serializationProvider,
IWindowManager windowManager,
ILogger logger)
: base(logger, serializationProvider, windowManager)
{
Data = accountData;
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceValidatorBase" /> class.
/// </summary>
/// <param name="unitOfWork">The unit of work.</param>
/// <param name="authenticationProvider">The authentication provider.</param>
/// <param name="messageProvider">The message provider.</param>
/// <param name="cachingProvider">The caching provider.</param>
/// <param name="serializationProvider">The serialization provider.</param>
public ServiceValidatorBase(
IUnitOfWork unitOfWork,
IAuthenticationProvider authenticationProvider,
IMessageProvider messageProvider,
ICachingProvider cachingProvider,
ISerializationProvider serializationProvider)
: base(unitOfWork, authenticationProvider, messageProvider, cachingProvider, serializationProvider)
{
}
public SerializationTests(ITestOutputHelper output)
{
_output = output;
_defaultJsonProvider = new JsonProvider();
_newtonsoftProvider = new NewtonsoftJsonProvider();
_utf8JsonProvider = new Utf8JsonProvider();
_messagePackProvider = new MessagePackProvider();
}
public HelloWorkflow(IHelloDialog dialog,
ISubscription subscription,
IDialogProvider dialogProvider,
ISerializationProvider serializationProvider)
:
base(dialog, subscription)
{
this.Connector = new Connector(dialogProvider, serializationProvider);
}
public OtherDataViewModel(
OtherData accountData,
ISerializationProvider serializationProvider,
IWindowManager windowManager,
ILogger logger)
: base(logger, serializationProvider, windowManager)
{
Data = accountData;
}
public UnicornDataProvider(ISerializationProvider serializationProvider, IPredicate predicate, IFieldPredicate fieldPredicate, IUnicornDataProviderLogger logger)
{
Assert.ArgumentNotNull(serializationProvider, "serializationProvider");
Assert.ArgumentNotNull(predicate, "predicate");
Assert.ArgumentNotNull(fieldPredicate, "fieldPredicate");
Assert.ArgumentNotNull(logger, "logger");
_logger = logger;
_predicate = predicate;
_fieldPredicate = fieldPredicate;
_serializationProvider = serializationProvider;
}
/// <summary>
/// Creates an instance of the class.
/// </summary>
/// <param name="regionName">The name of the NHibernate region the adapter is for.</param>
protected AppFabricCacheAdapter(string regionName)
{
RegionName = regionName;
if (!string.IsNullOrEmpty(AppFabricProviderSettings.Settings.SerializationProvider))
_serializationProvider = Activator.CreateInstance(ReflectHelper.ClassForName(AppFabricProviderSettings.Settings.SerializationProvider)) as ISerializationProvider;
else
{
_serializationProvider = null;
}
_lockHandles = new Dictionary<string, DataCacheLockHandle>();
_locksCache = AppFabricCacheFactory.Instance.GetCache(LocksRegionName, true);
}
/// <summary>
/// Initializes a new instance of the <see cref="AzureCacheAdapter"/> class.
/// </summary>
/// <param name="name">The name of the region</param>
/// <param name="serializationProvider"></param>
public AzureCacheAdapter(string name)
{
_serializationProvider = MrCMSApplication.Get<ISerializationProvider>();
//validate the params
if (String.IsNullOrEmpty(name))
{
Log.Info("No region name specified for cache region. Using default name of 'nhibernate'");
name = "nhibernate";
}
var mrCMSSection = WebConfigurationManager.GetSection("mrcms") as MrCMSConfigSection;
_webCache = AzureCacheFactory.Instance.GetCache(mrCMSSection == null ? "default" : mrCMSSection.CacheName);
_name = StripNonAlphaNumeric(name);
//configure the cache region based on the configured settings and any relevant nhibernate settings
}
public SerializationLoader(ISerializationProvider serializationProvider, ISourceDataProvider sourceDataProvider, IPredicate predicate, IEvaluator evaluator, ISerializationLoaderLogger logger, PredicateRootPathResolver predicateRootPathResolver)
{
Assert.ArgumentNotNull(serializationProvider, "serializationProvider");
Assert.ArgumentNotNull(sourceDataProvider, "sourceDataProvider");
Assert.ArgumentNotNull(predicate, "predicate");
Assert.ArgumentNotNull(evaluator, "evaluator");
Assert.ArgumentNotNull(logger, "logger");
Assert.ArgumentNotNull(predicateRootPathResolver, "predicateRootPathResolver");
Logger = logger;
PredicateRootPathResolver = predicateRootPathResolver;
Evaluator = evaluator;
Predicate = predicate;
SerializationProvider = serializationProvider;
SourceDataProvider = sourceDataProvider;
}
public RemotingPackageWriter(ISerializationProvider serializationProvider, PredicateRootPathResolver pathResolver)
{
_serializationProvider = serializationProvider;
_pathResolver = pathResolver;
}
public DocumentRepository( ICouchConfiguration configuration, ISerializationProvider serializer ) : base( configuration, serializer )
{
}
protected BaseSaveDocumentCollection( IHttpAction action, ICouchConfiguration configuration, ISerializationProvider serializer )
: base( action, configuration, serializer )
{
}
public ShortcutKeySettings(ISerializationProvider provider)
{
this._provider = provider;
}
public DefaultCodeEvaluator(IMessenger messenger, IQueue<EvaluateCodeCommand> messageQueue, ISerializationProvider serializationProvider)
{
serializer = serializationProvider;
commandQueue = messageQueue;
messageBus = messenger;
}
private SerializationLoader CreateTestLoader(ISerializationProvider serializationProvider, ISourceDataProvider sourceDataProvider, IPredicate predicate, IEvaluator evaluator, ISerializationLoaderLogger logger)
{
var mockSerializationProvider = new Mock<ISerializationProvider>();
var mockSourceDataProvider = new Mock<ISourceDataProvider>();
var mockPredicate = new Mock<IPredicate>();
var mockEvaluator = new Mock<IEvaluator>();
var mockLogger = new Mock<ISerializationLoaderLogger>();
var mockLogger2 = new Mock<ILogger>();
var pathResolver = new PredicateRootPathResolver(predicate ?? mockPredicate.Object, serializationProvider ?? mockSerializationProvider.Object, sourceDataProvider ?? mockSourceDataProvider.Object, mockLogger2.Object);
return new SerializationLoader(serializationProvider ?? mockSerializationProvider.Object,
sourceDataProvider ?? mockSourceDataProvider.Object,
predicate ?? mockPredicate.Object,
evaluator ?? mockEvaluator.Object,
logger ?? mockLogger.Object,
pathResolver);
}
public GeneralSettings(ISerializationProvider provider)
{
this._provider = provider;
}
private void Serialize(ISourceItem root, IPredicate predicate, ISerializationProvider serializationProvider, ILogger logger)
{
var predicateResult = predicate.Includes(root);
if (predicateResult.IsIncluded)
{
serializationProvider.SerializeItem(root);
foreach (var child in root.Children)
{
Serialize(child, predicate, serializationProvider, logger);
}
}
else
{
logger.Warn("[S] {0} because {1}".FormatWith(root.DisplayIdentifier, predicateResult.Justification));
}
}
