private static ILogger CreateLogger <T>()
{
var lf = new LoggerFactory();
var localLogger = LoggerFactoryExtensions.CreateLogger(lf, typeof(Logger <T>));
return(localLogger);
}
/// <summary>
/// Creates a stream of items that are to be published
/// </summary>
protected override IObservable <CandidateValidationTargetContext> CreateTargetProcessingStream(DateTime started, IPublishCandidateSource publishSourceRepository, IPublishValidator validator, PublishOptions jobOptions, IObservable <CandidateValidationContext> publishStream, IItemIndexService targetIndex, ITestableContentRepository testableContentRepository, IMediaRepository targetMediaRepository, IRequiredPublishFieldsResolver requiredPublishFieldsResolver, CancellationTokenSource errorSource, Guid targetId)
{
IPublishCandidateTargetValidator publishCandidateTargetValidator = !PublishOptionsMetadataExtensions.GetItemBucketsEnabled(jobOptions) ?
(IPublishCandidateTargetValidator) new PublishTargetParentValidator(publishSourceRepository, targetIndex) :
(IPublishCandidateTargetValidator) new PublishTargetBucketParentValidator(publishSourceRepository, targetIndex, PublishOptionsMetadataExtensions.GetBucketTemplateId(jobOptions));
publishStream = (IObservable <CandidateValidationContext>) new CandidatesParentValidationTargetProducer(
publishStream,
publishCandidateTargetValidator,
errorSource,
(ILogger)LoggerFactoryExtensions.CreateLogger <CandidatesParentValidationTargetProducer>(this._loggerFactory));
return(base.CreateTargetProcessingStream(
started,
publishSourceRepository,
validator,
jobOptions,
publishStream,
targetIndex,
testableContentRepository,
targetMediaRepository,
requiredPublishFieldsResolver,
errorSource,
targetId));
}
/// <summary>
/// Creates a stream of items that are candidates for publishing
/// </summary>
protected override ISourceObservable <CandidateValidationContext> CreatePublishSourceStream(DateTime started, PublishOptions options, IPublishCandidateSource publishSourceRepository, IPublishValidator validator, IPublisherOperationService publisherOperationService, CancellationTokenSource errorSource)
{
UnpublishedNodeSourceProducer unsp = new UnpublishedNodeSourceProducer(
started,
options.Languages,
options.Targets,
(IEnumerable <string>) new string[1] {
PublishOptionsMetadataExtensions.GetPublishType(options)
},
publishSourceRepository,
publisherOperationService,
validator,
this._options.UnpublishedOperationsLoadingBatchSize,
errorSource,
errorSource.Token,
(ILogger)LoggerFactoryExtensions.CreateLogger <UnpublishedNodeSourceProducer>(this._loggerFactory));
DeletedNodesSourceProducer dnsp = new DeletedNodesSourceProducer(
(ISourceObservable <CandidateValidationContext>)unsp,
started,
options.Languages,
options.Targets,
(IEnumerable <string>) new string[1] {
PublishOptionsMetadataExtensions.GetPublishType(options)
},
publisherOperationService,
this._options.UnpublishedOperationsLoadingBatchSize,
errorSource,
(ILogger)LoggerFactoryExtensions.CreateLogger <UnpublishedNodeSourceProducer>(this._loggerFactory),
null);
return((ISourceObservable <CandidateValidationContext>)dnsp);
}
public MaintenanceBase(ILoggerFactory loggerFactory)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Expected O, but got Unknown
_loggerFactory = loggerFactory ?? NullLoggerFactory.Instance;
_logger = LoggerFactoryExtensions.CreateLogger(_loggerFactory, GetType());
}
public ICoreLogger CreateLogger(object loggingCategory)
{
var categoryType = GetCategoryType(loggingCategory);
var logger = LoggerFactoryExtensions.CreateLogger(_factory, categoryType);
return(new CoreLogger(logger));
}
public void TestInitialize()
{
this.mockRepository = new MockRepository(MockBehavior.Strict);
this.mockHttpClientFactory = this.mockRepository.Create <IHttpClientFactory>();
ILoggerFactory loggerFactory = new LoggerFactory();
logger = LoggerFactoryExtensions.CreateLogger <TweetScrapingService>(loggerFactory);
var binDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location).TrimEnd(@"\bin".ToArray());
var dataFilePath = Path.GetFullPath(Path.Combine(binDirectory, Constants.DataFileName));
var testDataString = File.ReadAllText(dataFilePath);
testData = JsonConvert.DeserializeObject <List <ProcessedTweet> >(testDataString);
var dataFileMentionsName = Path.GetFullPath(Path.Combine(binDirectory, Constants.DataFileMentionsName));
var dataFileMentions = File.ReadAllText(dataFileMentionsName);
testDataMentions = JsonConvert.DeserializeObject <List <List <string> > >(dataFileMentions);
var dataFileHashtagsName = Path.GetFullPath(Path.Combine(binDirectory, Constants.DataFileHashtagsName));
var dataFileHashtags = File.ReadAllText(dataFileHashtagsName);
testDataHashtags = JsonConvert.DeserializeObject <List <List <string> > >(dataFileHashtags);
var dataFileLinksName = Path.GetFullPath(Path.Combine(binDirectory, Constants.DataFileLinksName));
var dataFileLinks = File.ReadAllText(dataFileLinksName);
testDataLinks = JsonConvert.DeserializeObject <List <List <string> > >(dataFileLinks);
var codesFileEmojiName = Path.GetFullPath(Path.Combine(binDirectory, Constants.EmojiCodesFileName));
emojiCodesUCompleteDash = File.ReadAllText(codesFileEmojiName);
var dataFileEmojiName = Path.GetFullPath(Path.Combine(binDirectory, Constants.DataFileEmojisName));
var dataFileEmojis = File.ReadAllText(dataFileEmojiName);
testDataEmojis = JsonConvert.DeserializeObject <List <string> >(dataFileEmojis);
var response = new Mock <HttpResponseMessage>();
response.SetupAllProperties();
var mockHttpMessageHandler = new Mock <HttpMessageHandler>();
mockHttpMessageHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.ReturnsAsync(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
RequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://google.com")
});
var client = new HttpClient(mockHttpMessageHandler.Object);
this.mockHttpClientFactory.Setup(o => o.CreateClient(It.IsAny <string>())).Returns(client);
}
// Token: 0x06000185 RID: 389 RVA: 0x000074FC File Offset: 0x000056FC
public HotUpdateRazorViewCompilerProvider(ApplicationPartManager applicationPartManager, RazorProjectEngine razorProjectEngine, IRazorViewEngineFileProviderAccessor fileProviderAccessor, CSharpCompiler csharpCompiler, IOptions <RazorViewEngineOptions> viewEngineOptionsAccessor, ILoggerFactory loggerFactory)
{
this._applicationPartManager = applicationPartManager;
this._razorProjectEngine = razorProjectEngine;
this._fileProviderAccessor = fileProviderAccessor;
this._csharpCompiler = csharpCompiler;
this._viewEngineOptions = viewEngineOptionsAccessor.Value;
this._logger = LoggerFactoryExtensions.CreateLogger <RazorViewCompiler>(loggerFactory);
this._createCompiler = new Func <IViewCompiler>(this.CreateCompiler);
}
public TaskQueue(int maxItems = int.MaxValue, byte maxDegreeOfParallelism = 1, bool autoStart = true, Action queueEmptyAction = null, ILoggerFactory loggerFactory = null)
{
_maxItems = maxItems;
_queueEmptyAction = queueEmptyAction;
_semaphore = new SemaphoreSlim(maxDegreeOfParallelism);
_logger = (loggerFactory != null ? LoggerFactoryExtensions.CreateLogger <TaskQueue>(loggerFactory) : null) ?? (NullLogger <TaskQueue> .Instance);
if (autoStart)
{
Start(default(CancellationToken));
}
}
public ScheduledTimer(Func <Task <DateTime?> > timerCallback, TimeSpan?dueTime = default(TimeSpan?), TimeSpan?minimumIntervalTime = default(TimeSpan?), ILoggerFactory loggerFactory = null)
{
_logger = ((loggerFactory != null) ? LoggerFactoryExtensions.CreateLogger <ScheduledTimer>(loggerFactory) : null) ?? (NullLogger <ScheduledTimer> .Instance);
_timerCallback = timerCallback ?? throw new ArgumentNullException("timerCallback");
_minimumInterval = (minimumIntervalTime ?? TimeSpan.Zero);
var dueTime2 = dueTime.HasValue ? ((int)dueTime.Value.TotalMilliseconds) : (-1);
_timer = new Timer(delegate
{
RunCallbackAsync().AnyContext().GetAwaiter().GetResult();
}, null, dueTime2, -1);
}
/// <summary>
/// Creates a stream of items that are candidates for publishing
/// </summary>
protected override ISourceObservable <CandidateValidationContext> CreatePublishSourceStream(DateTime started, PublishOptions options, IPublishCandidateSource publishSourceRepository, IPublishValidator validator, IPublisherOperationService publisherOperationService, CancellationTokenSource errorSource)
{
IPublishCandidate result = publishSourceRepository.GetNode(options.ItemId.Value).Result;
if (result == null)
{
throw new ArgumentNullException(string.Format("The publish could not be performed from a start item that doesn't exist : {0}.", (object)options.ItemId.Value));
}
IPublishCandidate publishCandidate = result.ParentId.HasValue ?
publishSourceRepository.GetNode(result.ParentId.Value).Result :
result;
ISourceObservable <CandidateValidationContext> sourceObservable =
(ISourceObservable <CandidateValidationContext>) new TreeNodeSourceProducer(
publishSourceRepository,
result,
validator,
options.Descendants,
this._options.SourceTreeReaderBatchSize,
errorSource,
(ILogger)LoggerFactoryExtensions.CreateLogger <TreeNodeSourceProducer>(this._loggerFactory));
if (PublishOptionsMetadataExtensions.GetItemBucketsEnabled(options) && publishCandidate.Node.TemplateId == PublishOptionsMetadataExtensions.GetBucketTemplateId(options))
{
sourceObservable =
(ISourceObservable <CandidateValidationContext>) new BucketNodeSourceProducer(
sourceObservable,
publishSourceRepository,
result,
PublishOptionsMetadataExtensions.GetBucketTemplateId(options),
errorSource,
(ILogger)LoggerFactoryExtensions.CreateLogger <BucketNodeSourceProducer>(this._loggerFactory));
}
DeletedNodesSourceProducer dnsp = new DeletedNodesSourceProducer(
sourceObservable,
started,
options.Languages,
options.Targets,
(IEnumerable <string>) new string[1] {
PublishOptionsMetadataExtensions.GetPublishType(options)
},
publisherOperationService,
this._options.UnpublishedOperationsLoadingBatchSize,
errorSource,
(ILogger)LoggerFactoryExtensions.CreateLogger <UnpublishedNodeSourceProducer>(this._loggerFactory),
(Predicate <PublisherOperation>)(op => Enumerable.Contains <Guid>((IEnumerable <Guid>)op.Path.Ancestors, options.ItemId.Value)));
return((ISourceObservable <CandidateValidationContext>)dnsp);
}
public UnitTest()
{
// create configuration for token service
var configuration = new ConfigurationBuilder()
.AddInMemoryCollection(new Dictionary <string, string>())
.Build();
// create logger for token service
ILogger <TokenService> logger = LoggerFactoryExtensions.CreateLogger <TokenService>(new LoggerFactory());
// create token service
this.tokenService = new TokenService(configuration, logger);
CreateClaimPrincipals();
}
public async Task <ActionResult> Index(string submitButton, string encryptedJwe, EncryptedJweViewModel encryptedJweViewModel)
{
try
{
var jwksUrl = ConfigurationManager.AppSettings["JwksUrl"];
var cacheDurationSeconds = long.Parse(ConfigurationManager.AppSettings["CacheDurationSeconds"]);
var privateJsonWebKeyList = new List <JsonWebKey>();
var privateRsaJson = System.IO.File.ReadAllText(AppDomain.CurrentDomain.RelativeSearchPath + @"\TestData\RsaPrivate.json");
var privateRsaJsonWebKey = JsonConvert.DeserializeObject <JsonWebKey>(privateRsaJson);
privateJsonWebKeyList.Add(privateRsaJsonWebKey);
var httpClient = new HttpClient();
var jwksService = new JwksService(httpClient, jwksUrl);
var keyResolver = new KeyResolver(privateJsonWebKeyList, jwksService, cacheDurationSeconds);
var loggerFactory = new LoggerFactory();
var logger = LoggerFactoryExtensions.CreateLogger <Encryption>(loggerFactory);
var encryption = new Encryption(keyResolver, logger);
if (submitButton == "Encrypt")
{
encryptedJweViewModel.EncryptedJwe = await encryption.EncryptAsync(encryptedJweViewModel.PhoneNumber);
}
else if (submitButton == "Decrypt")
{
encryptedJweViewModel.DecryptedPhoneNumber = await encryption.DecryptAsync(encryptedJwe);
}
}
catch (Exception ex)
{
encryptedJweViewModel.DecryptedPhoneNumber = string.Empty;
encryptedJweViewModel.ErrorMessage = ex.Message;
if (ex.InnerException != null)
{
encryptedJweViewModel.ErrorMessage += " " + ex.InnerException.Message;
}
}
return(View(encryptedJweViewModel));
}
public void TestInitialize()
{
this.mockRepository = new MockRepository(MockBehavior.Strict);
this.mockProcessedIncommingQueue = this.mockRepository.Create <IProcessedIncommingQueue>();
this.mockTweetScrapingService = this.mockRepository.Create <ITweetScrapingService>();
ILoggerFactory loggerFactory = new LoggerFactory();
logger = LoggerFactoryExtensions.CreateLogger <TweetScrapingService>(loggerFactory);
var binDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location).TrimEnd(@"\bin".ToArray());
var dataFilePath = Path.GetFullPath(Path.Combine(binDirectory, Constants.DataFileName));
var testDataString = File.ReadAllText(dataFilePath);
testData = JsonConvert.DeserializeObject <List <ProcessedTweet> >(testDataString);
var codesFileEmojiName = Path.GetFullPath(Path.Combine(binDirectory, Constants.EmojiCodesFileName));
emojiCodesUCompleteDash = File.ReadAllText(codesFileEmojiName);
this.mockHttpClientFactory = this.mockRepository.Create <IHttpClientFactory>();
}
public void TestInitialize()
{
this.mockRepository = new MockRepository(MockBehavior.Strict);
var binDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location).TrimEnd(@"\bin".ToArray());
var dataFilePath = Path.GetFullPath(Path.Combine(binDirectory, Constants.DataFileRawTweetName));
rawTweet = File.ReadAllText(dataFilePath);
this.mockHttpClientFactory = this.mockRepository.Create <IHttpClientFactory>();
this.mockProcessedIncommingQueue = this.mockRepository.Create <IProcessedIncommingQueue>();
this.mockIncommingTweetQueue = this.mockRepository.Create <IIncommingTweetQueue>();
this.mockTweetScrapingService = this.mockRepository.Create <ITweetScrapingService>();
this.mockIncommingTweetQueuePoison = this.mockRepository.Create <IIncommingTweetQueuePoison>();
this.mockTweetAggregationService = this.mockRepository.Create <ITweetAggregationService>();
ILoggerFactory loggerFactory = new LoggerFactory();
logger = LoggerFactoryExtensions.CreateLogger <TweetScrapingService>(loggerFactory);
this.mockTweetAggregationService.Setup(o => o.ProcessIncommingTweet(this.mockHttpClientFactory.Object, It.IsAny <string>(),
It.IsAny <string>(), It.IsAny <int>(), logger)).Returns(Task.CompletedTask);
}
public void CreateCurrentClassLogger_creates_a_logger_with_this_class_name()
{
var logger = LoggerFactoryExtensions.CreateCurrentClassLogger(mockLoggerFactory.Object);
mockLoggerFactory.Verify(p => p.CreateLogger(typeof(LoggerFactoryExtensionsTests).FullName), Times.Once);
}
public static void AddLoggerResolving(this IContainer container)
{
container.Register <ILogger>(Made.Of(
() => LoggerFactoryExtensions.CreateLogger(Arg.Of <ILoggerFactory>(), Arg.Index <Type>(0)),
request => request.Parent.ImplementationType));
}
public static Log getLog(Type classType)
{
return(new Util.Log(LoggerFactoryExtensions.CreateLogger(factory, classType)));
}
internal static ILogger GetLogger <T>()
{
return(LoggerFactoryExtensions.CreateLogger <T>(new NLog.Extensions.Logging.NLogLoggerFactory()));
}
public static ILogger CreateLogger <T>() => LoggerFactoryExtensions.CreateLogger <T>(Factory);
