/// <summary>
/// Initializes a new instance of the <see cref="BaseTestClass"/> class.
/// </summary>
public BaseTestClass()
{
ServicePointManager.ServerCertificateValidationCallback += (sender, cert, chain, sslPolicyErrors) => true;
_loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
_baseTestLogger = _loggerFactory.CreateLogger("BaseTest");
// Set a logger for fo-dicom network operations so that they show up in VS output when debugging
Dicom.Log.LogManager.SetImplementation(new Dicom.Log.TextWriterLogManager(new DataProviderTests.DebugTextWriter()));
_testAETConfigProvider = new AETConfigProvider(_loggerFactory.CreateLogger("ModelSettings"), _basePathConfigs);
TestGatewayProcessorConfigProvider = new GatewayProcessorConfigProvider(_loggerFactory.CreateLogger("ProcessorSettings"), _basePathConfigs);
_testGatewayReceiveConfigProvider = new GatewayReceiveConfigProvider(_loggerFactory.CreateLogger("ProcessorSettings"), _basePathConfigs);
}
// public Seed(UserManager<ApplicationUser> userManager, RoleManager<IdentityRole> roleManager, ISession session)
// {
// _session = session;
// _roleManager = roleManager;
// _userManager = userManager;
// }
public Seed(KorisnikManager userManager, ISession session, Microsoft.Extensions.Logging.ILoggerFactory loggerFactory, IHostingEnvironment env)
{
_session = session;
_userManager = userManager;
_logger = loggerFactory.CreateLogger <Seed>();
_env = env;
}
public TemplateController(NHibernate.ISession session, ILoggerFactory loggerFactory, IHttpContextAccessor contextAccessor, IHostingEnvironment hostingEnvironment)
{
_logger = loggerFactory.CreateLogger <TemplateController>();
_session = session;
_httpContextAccessor = contextAccessor;
_hostingEnvironment = hostingEnvironment;
}
public void Exception()
{
var handlerMock = new Mock <HttpMessageHandler>();
handlerMock
.Protected()
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>()
)
.Throws <HttpRequestException>()
.Verifiable();
int pageIndex = 0;
Mock <IHttpClientService> mockHttpClientService = new Mock <IHttpClientService>();
mockHttpClientService.Setup(s => s.CreateDefaultHttpClient()).Returns(() => new HttpClient(handlerMock.Object));
using Microsoft.Extensions.Logging.ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
IHttpClientService httpClientService = GetHttpClientService(HttpStatusCode.RequestTimeout, string.Empty);
IImmunizationDelegate immsDelegate = new RestImmunizationDelegate(loggerFactory.CreateLogger <RestImmunizationDelegate>(), mockHttpClientService.Object, this.configuration);
var actualResult = immsDelegate.GetImmunizations("token", pageIndex).Result;
Assert.True(actualResult.ResultStatus == Common.Constants.ResultType.Error && actualResult.ResultError.ErrorCode == "testhostServer-CE-PHSA");
}
/// <summary>
/// Required Method to Get a Logger, for the given name
/// </summary>
/// <param name="name">Name</param>
/// <returns>Quartz.Logging.Logger</returns>
public Quartz.Logging.Logger GetLogger(string name)
{
return((level, func, exception, parameters) =>
{
if (func != null)
{
var state = string.Format(func(), parameters);
var logger = _loggerFactory.CreateLogger("Quartz");
switch (level)
{
case Quartz.Logging.LogLevel.Trace:
logger.LogTrace(state);
break;
case Quartz.Logging.LogLevel.Debug:
logger.LogDebug(state);
break;
case Quartz.Logging.LogLevel.Warn:
if (exception != null)
{
logger.LogWarning(exception, state);
}
else
{
logger.LogWarning(state);
}
break;
case Quartz.Logging.LogLevel.Error:
if (exception != null)
{
logger.LogError(exception, state);
}
else
{
logger.LogError(state);
} break;
case Quartz.Logging.LogLevel.Fatal:
if (exception != null)
{
logger.LogCritical(exception, state);
}
else
{
logger.LogCritical(state);
}
break;
default:
logger.LogInformation(state);
break;
}
}
return true;
});
}
public void Ok()
{
ImmunizationViewResponse expectedViewResponse = new ImmunizationViewResponse()
{
Id = Guid.NewGuid(),
SourceSystemId = "mockSourceSystemId",
Name = "mockName",
OccurrenceDateTime = DateTime.ParseExact("2020/09/10 17:16:10.809", "yyyy/MM/dd HH:mm:ss.fff", CultureInfo.InvariantCulture)
};
PHSAResult <ImmunizationResponse> phsaResponse = new PHSAResult <ImmunizationResponse>()
{
Result = new ImmunizationResponse()
{
ImmunizationViews = new List <ImmunizationViewResponse>()
{
expectedViewResponse
}
}
};
string json = JsonSerializer.Serialize(phsaResponse, null);
using Microsoft.Extensions.Logging.ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
IHttpClientService httpClientService = GetHttpClientService(HttpStatusCode.OK, json);
IImmunizationDelegate immsDelegate = new RestImmunizationDelegate(loggerFactory.CreateLogger <RestImmunizationDelegate>(), httpClientService, this.configuration);
var actualResult = immsDelegate.GetImmunizations("token", 0).Result;
Assert.Equal(Common.Constants.ResultType.Success, actualResult.ResultStatus);
Assert.NotNull(actualResult.ResourcePayload);
Assert.Equal(1, actualResult.ResourcePayload.Result.ImmunizationViews.Count());
}
public static async Task SeedAsync(IApplicationBuilder applicationBuilder, Microsoft.Extensions.Logging.ILoggerFactory loggerFactory, int?retry = 0)
{
var retryForAvaiability = retry.Value;
try
{
using (var scope = applicationBuilder.ApplicationServices.CreateScope())
{
var context = (UserContext)scope.ServiceProvider.GetService(typeof(UserContext));
var logger = (ILogger <UserContextSeed>)scope.ServiceProvider.GetService(typeof(ILogger <UserContextSeed>));
logger.LogDebug("Begin UserContextSeed SeedAsync");
//获取到数据库的migrate
context.Database.Migrate();
if (!context.Users.Any())
{
context.Users.Add(new Model.AppUser {
Name = "lmc"
});
context.SaveChanges();
}
}
}
catch (Exception ex)
{
if (retryForAvaiability < 10)
{
retryForAvaiability++;
var logger = loggerFactory.CreateLogger(typeof(UserContextSeed));
await SeedAsync(applicationBuilder, loggerFactory, retryForAvaiability);
}
}
}
//private SmtpClient smtp;
//private readonly IHttpContextAccessor _httpContextAccessor;
//private readonly IEmailSender _emailSender;
//private readonly ISmsSender _smsSender;
public ParametarController(
ILoggerFactory loggerFactory,
ISession session)
{
_logger = loggerFactory.CreateLogger<Parametar>();
_session = session;
}
public PmsDatabaseSessionFactory(string pmsConnection, ILoggerFactory factory)
{
if (pmsConnection == null)
{
throw new ArgumentNullException(nameof(pmsConnection));
}
if (string.IsNullOrWhiteSpace(pmsConnection))
{
throw new ArgumentException("Value cannot be whitespace.", nameof(pmsConnection));
}
_sessionFactory =
Fluently.Configure()
.Database(
() => SqlServerManagedDataClientConfiguration.SqlServer.ConnectionString(pmsConnection)
.AdoNetBatchSize(50)
).Mappings(m => m.FluentMappings.AddFromAssemblyOf <PmsUnitOfWork>())
.ExposeConfiguration(SchemaMetadataUpdater.QuoteTableAndColumns)
.ExposeConfiguration(c => c.SetProperty("command_timeout", "60"))
.ExposeConfiguration(c => c.SetInterceptor(
new SqlStatementInterceptor(factory.CreateLogger <SqlStatementInterceptor>())))
.BuildConfiguration()
.BuildSessionFactory();
}
public OrganizationController(ICountryManager countryManager, ICompanyManager companyManager, IUserManagerWrapper <ApplicationUser> userManager, ILoggerFactory loggerFactory)
{
_countryManager = countryManager;
_companyManager = companyManager;
_userManager = userManager;
_logger = loggerFactory.CreateLogger(nameof(OrganizationController));
}
/// <summary>
/// Instantiates an authentication handler the can either use the device GUID, an API token or a JWT
/// to authenticate requests to the API
/// </summary>
/// <param name="options"></param>
/// <param name="logger"></param>
/// <param name="encoder"></param>
/// <param name="clock"></param>
public JWTCookieAuthenticationHandler(
IOptionsMonitor <AuthenticationSchemeOptions> options,
ILoggerFactory logger,
UrlEncoder encoder,
ISystemClock clock)
: base(options, logger, encoder, clock)
{
_logger = logger.CreateLogger <JWTCookieAuthenticationHandler>();
}
public Feign.Logging.ILogger CreateLogger(Type type)
{
Microsoft.Extensions.Logging.ILogger logger = _loggerFactory?.CreateLogger(type);
if (logger == null)
{
return null;
}
return new Logger(logger);
}
public MicrosoftLoggerWrapper(Microsoft.Extensions.Logging.ILoggerFactory loggerFactory)
{
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
_innerLogger = loggerFactory.CreateLogger("Default");
}
public void ShouldGetMedications()
{
DateTime loadDate = DateTime.Parse("2020/09/29");
string DIN = "00000000";
List <DrugProduct> fedData = new List <DrugProduct>()
{
new DrugProduct()
{
DrugIdentificationNumber = DIN,
UpdatedDateTime = loadDate,
}
};
List <PharmaCareDrug> provData = new List <PharmaCareDrug>()
{
new PharmaCareDrug()
{
DINPIN = DIN,
UpdatedDateTime = loadDate,
},
};
Dictionary <string, Models.MedicationInformation> expected = new Dictionary <string, Models.MedicationInformation>()
{
{
DIN,
new Models.MedicationInformation()
{
DIN = DIN,
FederalData = new FederalDrugSource()
{
UpdateDateTime = loadDate,
DrugProduct = fedData.First(),
},
ProvincialData = new ProvincialDrugSource()
{
UpdateDateTime = loadDate,
PharmaCareDrug = provData.First(),
}
}
}
};
Mock <IDrugLookupDelegate> mockDelegate = new Mock <IDrugLookupDelegate>();
mockDelegate.Setup(s => s.GetDrugProductsByDIN(It.IsAny <List <string> >())).Returns(fedData);
mockDelegate.Setup(s => s.GetPharmaCareDrugsByDIN(It.IsAny <List <string> >())).Returns(provData);
using Microsoft.Extensions.Logging.ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
ILogger <RestMedicationService> logger = loggerFactory.CreateLogger <RestMedicationService>();
IMedicationService service = new RestMedicationService(logger, mockDelegate.Object);
var actual = service.GetMedications(new List <string>());
Assert.True(actual.IsDeepEqual(expected));
}
/// <summary>
/// Create a <see cref="MicrosoftExtensionsLoggingLogger"/> instance from an <see cref="MEL.ILoggerFactory"/> instance which will use the specified type to distinguish logs
/// </summary>
/// <param name="loggerFactory"><see cref="MEL.ILoggerFactory"/> to create <see cref="MEL.ILogger"/> instance from</param>
/// <param name="type">Type to use as a header for log entries</param>
public MicrosoftExtensionsLoggingLogger(MEL.ILoggerFactory loggerFactory, Type type)
{
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
_logger = loggerFactory.CreateLogger(type);
}
public MenuServices(IMenuRepository menuRepository, IUnitOfWork unitOfWork, IRepository <RoleMenuEntity, Guid> roleMenuRepository, IMenuFunctionRepository menuFunction, IPrincipal principal, UserManager <User> userManager, RoleManager <Role> roleManager, IRepository <UserRole, Guid> repositoryUserRole, Microsoft.Extensions.Logging.ILoggerFactory loggerFactory /*, ICache cache*/)
{
_menuRepository = menuRepository;
_roleMenuRepository = roleMenuRepository;
this._menuFunction = menuFunction;
_unitOfWork = unitOfWork;
_iIdentity = principal.Identity;
_userManager = userManager;
_roleManager = roleManager;
_repositoryUserRole = repositoryUserRole;
_logger = loggerFactory.CreateLogger <MenuServices>();
//_cache = cache;
}
public DbContextCollection(DbContextScope dbContextScope, IAmbientDbContextFactory ambientDbContextFactory, ILoggerFactory loggerFactory, bool readOnly, IsolationLevel?isolationLevel)
{
_disposed = false;
_completed = false;
_logger = loggerFactory.CreateLogger <DbContextCollection>();
InitializedDbContexts = new Dictionary <Type, (DbContext DbContext, IDbContextProxyBypass Proxy)>();
_transactions = new Dictionary <DbContext, IDbContextTransaction>();
_dbContextScope = dbContextScope;
_readOnly = readOnly;
_isolationLevel = isolationLevel;
_ambientDbContextFactory = ambientDbContextFactory;
}
/// <summary>
/// Create a new instance of the <see cref="ConfigurationService"/> class.
/// </summary>
/// <param name="innerEyeSegmentationClient">Optional InnerEye segmentation client.</param>
/// <param name="getConfigurationServiceConfig">Configuration service config callback.</param>
/// <param name="services">The services.</param>
/// <returns>New ConfigurationService<T>.</returns>
protected ConfigurationService CreateConfigurationService(
IInnerEyeSegmentationClient innerEyeSegmentationClient = null,
Func <ConfigurationServiceConfig> getConfigurationServiceConfig = null,
params IService[] services) =>
new ConfigurationService(
innerEyeSegmentationClient != null ? () => innerEyeSegmentationClient : TestGatewayProcessorConfigProvider.CreateInnerEyeSegmentationClient(),
getConfigurationServiceConfig ?? TestGatewayProcessorConfigProvider.ConfigurationServiceConfig,
_loggerFactory.CreateLogger("ConfigurationService"),
services);
public PonudaController(ISession session, ILoggerFactory loggerFactory, Microsoft.AspNetCore.Http.IHttpContextAccessor contextAccessor, IStringLocalizerFactory factory)
{
_logger = loggerFactory.CreateLogger <PonudaController>();
_session = session;
_httpContextAccessor = contextAccessor;
var korisnik = _session.QueryOver <Korisnik>()
.Where(x => x.KorisnickoIme == contextAccessor.HttpContext.User.Identity.Name)
.SingleOrDefault <Korisnik>();
var type = typeof(Prevod);
var assemblyName = new AssemblyName(type.GetTypeInfo().Assembly.FullName);
_localizer = factory.Create("Prevod" + korisnik.Lang, assemblyName.Name);
}
public PVBackgroundService(Microsoft.Extensions.Logging.ILoggerFactory loggerFactory, IModbusFactory modbus_factory,
MqttClientProxyCollection mqttClientProxies, IRedisConnectionFactory redisFactory,
IConfiguration configuration)
{
logger = loggerFactory.CreateLogger <PVBackgroundService>();
config = configuration;
mqtt_clients = mqttClientProxies;
mqtt_config = configuration.GetSection("MQTTBrokers").Get <MqttConfig>();
SiteId = configuration.GetSection("SiteId").Get <int>();
string mssql_conn = configuration.GetConnectionString("mssql");
redis = redisFactory.Connection().GetDatabase(1);
DeviceName = configuration.GetSection("Modbus:DeviceName").Get <string>();
DeviceName = DeviceName.Substring(0, DeviceName.Length - 1);
sessionFactory = new MsSqlAccessManager().CreateSessionFactory(mssql_conn);
}
public void NoContent()
{
int pageIndex = 0;
RequestResult <IEnumerable <ImmunizationResponse> > expectedResult = new RequestResult <IEnumerable <ImmunizationResponse> >()
{
ResultStatus = Common.Constants.ResultType.Error,
PageIndex = pageIndex,
};
using Microsoft.Extensions.Logging.ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
IHttpClientService httpClientService = GetHttpClientService(HttpStatusCode.NoContent, string.Empty);
IImmunizationDelegate immsDelegate = new RestImmunizationDelegate(loggerFactory.CreateLogger <RestImmunizationDelegate>(), httpClientService, this.configuration);
var actualResult = immsDelegate.GetImmunizations("token", pageIndex).Result;
Assert.True(actualResult.ResultStatus == Common.Constants.ResultType.Success && actualResult.ResourcePayload.Count() == 0);
}
public ModbusDigitalProcessingService(Microsoft.Extensions.Logging.ILoggerFactory loggerFactory,
IDataAccess mysql_dataAccess, IRedisConnectionFactory redisFactory,
IModbusFactory modbus_factory, IConfiguration configuration, EventPublisherWorker worker, EventMap map,
ModbusSystem modbusSystem)
{
logger = loggerFactory.CreateLogger <ModbusBackgroundService>();
config = configuration;
modbusFactory = modbus_factory;
eventPublisherWorker = worker;
UpdatePeriod = configuration.GetSection("EventPollInterval").Get <TimeSpan>();
modbus = modbusSystem;
SiteId = configuration.GetSection("SiteId").Get <short>();
redis = redisFactory.Connection().GetDatabase();
DeviceIndex = configuration.GetSection("DeviceIndex").Get <int>();
dbAccess = mysql_dataAccess;
event_map = map;
}
public static void Seed(EFContext context, ILoggerFactory loggerFactory)
{
_context = context;
_logger = loggerFactory.CreateLogger <SeedData>();
try
{
SeedCustomers();
SeedProducts();
context.SaveChangesAsync();
_logger.LogInformation("Seeded Data");
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
}
}
public void Default()
{
int pageIndex = 0;
RequestResult <IEnumerable <ImmunizationResponse> > expectedResult = new RequestResult <IEnumerable <ImmunizationResponse> >()
{
ResultStatus = Common.Constants.ResultType.Error,
ResultError = new RequestResultError()
{
ResultMessage = $"Unable to connect to Immunizations Endpoint, HTTP Error {HttpStatusCode.RequestTimeout}",
ErrorCode = ErrorTranslator.ServiceError(ErrorType.CommunicationExternal, ServiceType.PHSA)
},
PageIndex = pageIndex,
};
using Microsoft.Extensions.Logging.ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
IHttpClientService httpClientService = GetHttpClientService(HttpStatusCode.RequestTimeout, string.Empty);
IImmunizationDelegate immsDelegate = new RestImmunizationDelegate(loggerFactory.CreateLogger <RestImmunizationDelegate>(), httpClientService, this.configuration);
var actualResult = immsDelegate.GetImmunizations("token", pageIndex).Result;
Assert.True(actualResult.IsDeepEqual(expectedResult));
}
public void IterationSetup()
{
_stopStreamProcessorSource = new CancellationTokenSource();
var numEventsProcessed = 0;
_streamProcessorsToRun = Enumerable.Range(0, EventHandlerFilters).Select(_ =>
{
var eventHandlerId = new EventProcessorId(Guid.NewGuid());
return(_streamProcessors.TryCreateAndRegister(
ScopeId.Default,
eventHandlerId,
new EventLogStreamDefinition(),
tenant => new TypeFilterWithEventSourcePartition(
ScopeId.Default,
new TypeFilterWithEventSourcePartitionDefinition(StreamId.EventLog, eventHandlerId.Value, _eventTypes, Partitioned),
GetEventWriterForTenant(tenant),
_loggerFactor.CreateLogger <TypeFilterWithEventSourcePartition>()),
Runtime.CreateExecutionContextFor("e3921d20-da26-422e-bf13-e959a5f505ef"),
_stopStreamProcessorSource.Token).Result);
}).ToArray();
IWriteEventsToStreams GetEventWriterForTenant(TenantId tenant)
{
var writer = _getEventsToStreamsWriter(tenant);
var wrappedWriter = new Mock <IWriteEventsToStreams>();
wrappedWriter
.Setup(_ => _.Write(It.IsAny <CommittedEvent>(), It.IsAny <ScopeId>(), It.IsAny <StreamId>(), Moq.It.IsAny <PartitionId>(), Moq.It.IsAny <CancellationToken>()))
.Returns <CommittedEvent, ScopeId, StreamId, PartitionId, CancellationToken>(async(@event, scope, stream, partition, cancellation) =>
{
Interlocked.Add(ref numEventsProcessed, 1);
await writer.Write(@event, scope, stream, partition, cancellation).ConfigureAwait(false);
if (numEventsProcessed == NumberEventsToProcess)
{
_stopStreamProcessorSource.Cancel();
}
});
return(wrappedWriter.Object);
}
}
public void BadData()
{
string json = "{}";
RequestResult <IEnumerable <ImmunizationResponse> > expectedResult = new RequestResult <IEnumerable <ImmunizationResponse> >()
{
PageIndex = 0,
ResultStatus = Common.Constants.ResultType.Error,
ResultError = new RequestResultError()
{
ResultMessage = $"Error with JSON data",
ErrorCode = ErrorTranslator.ServiceError(ErrorType.CommunicationExternal, ServiceType.PHSA)
},
};
using Microsoft.Extensions.Logging.ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
IHttpClientService httpClientService = GetHttpClientService(HttpStatusCode.OK, json);
IImmunizationDelegate immsDelegate = new RestImmunizationDelegate(loggerFactory.CreateLogger <RestImmunizationDelegate>(), httpClientService, this.configuration);
var actualResult = immsDelegate.GetImmunizations("token", 0).Result;
Assert.True(expectedResult.IsDeepEqual(actualResult));
}
public async Task <IActionResult> Service([FromServices] IWechatGateway gateway,
[FromQuery] string signature,
[FromQuery] string timestamp,
[FromQuery] string nonce,
[FromQuery] string echostr,
[FromRoute] string appID = "",
[FromServices] ILoggerFactory logger = null
)
{
if (gateway == null)
{
return(Content("请先注册微信小程序"));
}
logger?.CreateLogger("miniprogram")?.Log(LogLevel.Trace, $"微信调用:signature={signature},timestamp={timestamp},nonce={nonce},echostr={echostr}");
if (string.IsNullOrWhiteSpace(appID))
{
return(Content("AppID不能为空"));
}
var config = gateway.Get <MiniProgramConfiguration>(appID);
if (config == null)
{
return(Content("该AppID非小程序配置"));
}
if (CheckSignature.Check(signature, timestamp, nonce, config.Token))
{
return(Content(echostr)); //返回随机字符串则表示验证通过
}
else
{
return(Content($"failed:{signature},{CheckSignature.GetSignature(timestamp, nonce, config.Token).ToString()}。如果你在浏览器中看到这句话，说明此地址可以被作为微信公众账号后台的Url，请注意保持Token一致。"));
}
}
public ResourceFilterAttribute(Microsoft.Extensions.Logging.ILoggerFactory loggerFactory)
{
logger = loggerFactory.CreateLogger <ResourceFilterAttribute>();
}
public LimangoWebsiteProcessor(IEmail email, IProcessRepository hash, Microsoft.Extensions.Logging.ILoggerFactory DepLoggerFactory)
{
this.email = email;
this.hash = hash;
this.logger = DepLoggerFactory.CreateLogger("Controllers.TestController");
}
internal NuGetLogger(Microsoft.Extensions.Logging.ILoggerFactory loggerFactory)
{
_baseLogger = loggerFactory.CreateLogger("NuGetLogger") ?? throw new System.ArgumentNullException(nameof(loggerFactory));
}
