public override void Configure(CustomConfiguration conf, CustomTarget target)
{
base.Configure(conf, target);
conf.SetLib();
conf.IncludePaths.Add("include");
}
private void ExecuteRequest()
{
var watch = Stopwatch.StartNew();
ConsoleHelper.WriteHeader("Capturing a Full Transaction");
CustomConfiguration configuration = new CustomConfiguration()
{
DefaultEndpoint = ConfigurationManager.AppSettings["cielo.endpoint.default"],
QueryEndpoint = ConfigurationManager.AppSettings["cielo.endpoint.query"],
MerchantId = ConfigurationManager.AppSettings["cielo.customer.id"],
MerchantKey = ConfigurationManager.AppSettings["cielo.customer.key"],
ReturnUrl = ConfigurationManager.AppSettings["cielo.return.url"],
};
CieloService cieloService = new CieloService(configuration);
try
{
var response = cieloService.CaptureTransaction(Guid.Parse("55158bb3-2bb9-4e76-a92b-708b51245f4b"));
ConsoleHelper.WriteResult(response);
}
catch (ResponseException ex)
{
ConsoleHelper.WriteError(ex);
}
catch (Exception ex)
{
ConsoleHelper.WriteError(ex);
}
watch.Stop();
ConsoleHelper.WriteFooter(watch.ElapsedMilliseconds);
}
private void ConfigureConfiguration(IServiceCollection services)
{
//Objet représentant la configuration de l'app.
_customConfig = new CustomConfiguration();
_baseConfig.Bind("Configuration", _customConfig);
services.AddSingleton(_customConfig);
}
public void BeginSessionWithConnectionAndTransactionDelegatesToSessionFactory()
{
// assemble
var connection = new Mock <IDbConnection>();
var transaction = new Mock <IDbTransaction>();
var session = new Mock <ISession>();
var mockEngine = MakeMockEngine();
var mockSessionFactory = MakeMockSf();
mockSessionFactory.Setup(m => m.Create(mockEngine.Object, connection.Object, transaction.Object, false, false, false))
.Returns(session.Object)
.Verifiable();
var target = new CustomConfiguration(
mockEngine.Object,
MakeMockDbProviderFactory().Object,
MakeMockMapper().Object,
mockSessionFactory.Object);
// act
var actual = target.BeginSession(connection.Object, transaction.Object);
// assert
Assert.Equal(session.Object, actual);
mockSessionFactory.Verify();
}
public virtual void Configure(CustomConfiguration conf, CustomTarget target)
{
conf.ProjectPath = Constants.ProjectPath;
conf.TargetPath = Constants.OutputPath + @"[target.Name]";
conf.IntermediatePath = Constants.IntermediatePath + @"[target.Name]\[project.Name]";
//
conf.IncludePaths.Add(Constants.CodePath);
//
conf.DisableExceptions();
conf.Options.Add(Options.Vc.Compiler.CppLanguageStandard.CPP17);
conf.Options.Add(Options.Vc.Compiler.RTTI.Disable);
switch (target.Optimization)
{
case Optimization.Debug:
conf.Options.Add(Options.Vc.Compiler.Optimization.Disable);
break;
case Optimization.Release:
case Optimization.Retail:
conf.Options.Add(Options.Vc.Compiler.Optimization.MaximizeSpeed);
break;
}
}
public IEndpointConfiguration Bootstrap(EndpointDefinition endpointDefinition)
{
if (endpointDefinition.MachineName != null)
{
RuntimeEnvironment.MachineNameAction = () => endpointDefinition.MachineName;
}
busConfiguration = new BusConfiguration();
busConfiguration.Conventions()
.DefiningMessagesAs(
t => t.Namespace != null && t.Namespace.EndsWith(".Messages") && t != typeof(TestEvent));
busConfiguration.Conventions().DefiningEventsAs(t => t == typeof(TestEvent));
busConfiguration.EndpointName(endpointDefinition.Name);
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.EnableInstallers();
busConfiguration.UseTransport <SqlServerTransport>();
customConfiguration = new CustomConfiguration();
busConfiguration.CustomConfigurationSource(customConfiguration);
messageStore = new MessageStore();
subscriptionStore = new SubscriptionStore();
callbackResultStore = new CallbackResultStore();
busConfiguration.RegisterComponents(c => c.RegisterSingleton(messageStore));
busConfiguration.RegisterComponents(c => c.RegisterSingleton(subscriptionStore));
busConfiguration.Pipeline.Register <SubscriptionBehavior.Registration>();
return(this);
}
public ScaffoldingDto ScaffoldDatabase(string connectionString, string rootNamespace, string contextName)
{
var scaffUtils = new ScaffoldingUtilities();
var csharpUtils = new CSharpUtilities();
var provider = new SqlServerAnnotationProvider();
var customConfiguration = new CustomConfiguration(connectionString, contextName, rootNamespace, true);
var entityTypeWriter = new EntityTypeWriter(csharpUtils);
var dbContextWriter = new SingularDbContextWriter(scaffUtils, csharpUtils);
var configurationFactory = new ConfigurationFactory(provider, csharpUtils, scaffUtils);
var loggerFactory = new LoggerFactory();
var logger = loggerFactory.CreateLogger <SqlServerDatabaseModelFactory>();
var revEngeConfig = new ReverseEngineeringConfiguration {
ConnectionString = connectionString
};
var sqlScaffoldModelFactory = new SingularScaffoldingModelFactory(new LoggerFactory(),
new SqlServerTypeMapper(), new SqlServerDatabaseModelFactory(logger), new CandidateNamingService());
var codeWriter = new StringBuilderCodeWriter(new FileSystemFileService(), dbContextWriter, entityTypeWriter);
var generator = new ReverseEngineeringGenerator(sqlScaffoldModelFactory, configurationFactory, codeWriter);
var metaModel = generator.GetMetadataModel(revEngeConfig);
var modelConfiguration = configurationFactory.CreateModelConfiguration(metaModel, customConfiguration);
var dbContextData = dbContextWriter.WriteCode(modelConfiguration);
var scaffoldingDto = new ScaffoldingDto
{
DbContextSource = dbContextData,
ModelSources = modelConfiguration.EntityConfigurations
.Select(entityConfiguration => entityTypeWriter.WriteCode(entityConfiguration))
.ToImmutableList()
};
return(scaffoldingDto);
}
public void Initialize()
{
Database = IocManager.Resolve<DatabaseConfiguration>();
Localization = IocManager.Resolve<LocalizationConfiguration>();
Auditing = IocManager.Resolve<AuditConfiguration>();
Custom = IocManager.Resolve<CustomConfiguration>();
}
private void ExecuteRequest()
{
var watch = Stopwatch.StartNew();
ConsoleHelper.WriteHeader("Checking a Transaction");
CustomConfiguration configuration = new CustomConfiguration()
{
DefaultEndpoint = ConfigurationManager.AppSettings["cielo.endpoint.default"],
QueryEndpoint = ConfigurationManager.AppSettings["cielo.endpoint.query"],
MerchantId = ConfigurationManager.AppSettings["cielo.customer.id"],
MerchantKey = ConfigurationManager.AppSettings["cielo.customer.key"],
ReturnUrl = ConfigurationManager.AppSettings["cielo.return.url"],
};
CieloService cieloService = new CieloService(configuration);
try
{
var response = cieloService.CheckTransaction(paymentId: Guid.Parse("1a2d178a-dc87-4627-92a2-b5d18ba076cd"));
ConsoleHelper.WriteResult(response);
}
catch (ResponseException ex)
{
ConsoleHelper.WriteError(ex);
}
catch (Exception ex)
{
ConsoleHelper.WriteError(ex);
}
watch.Stop();
ConsoleHelper.WriteFooter(watch.ElapsedMilliseconds);
}
public static void AddAsDependency(CustomConfiguration conf, CustomTarget target)
{
var rootPath = Constants.ThirdPartyPath + @"SFML-2.5.1\";
//Include
conf.IncludePrivatePaths.Add(rootPath + @"include");
//Lib files
conf.LibraryPaths.Add(rootPath + @"x64\lib");
var suffix = target.Optimization == Optimization.Debug ? "-d" : "";
conf.LibraryFiles.Add(
@"sfml-audio" + suffix,
@"sfml-graphics" + suffix,
@"sfml-network" + suffix,
@"sfml-system" + suffix,
@"sfml-window" + suffix
);
//Dll files
conf.TargetCopyFiles.Add(
rootPath + @"x64\bin\sfml-audio" + suffix + @"-2.dll",
rootPath + @"x64\bin\sfml-graphics" + suffix + @"-2.dll",
rootPath + @"x64\bin\sfml-network" + suffix + @"-2.dll",
rootPath + @"x64\bin\sfml-system" + suffix + @"-2.dll",
rootPath + @"x64\bin\sfml-window" + suffix + @"-2.dll"
);
}
public IEndpointConfiguration Bootstrap(EndpointDefinition endpointDefinition)
{
if (endpointDefinition.MachineName != null)
{
RuntimeEnvironment.MachineNameAction = () => endpointDefinition.MachineName;
}
configure = Configure.With();
configure.DefaultBuilder();
configure.DefineEndpointName(endpointDefinition.Name);
Address.InitializeLocalAddress(endpointDefinition.Name);
configure.DefiningMessagesAs(t => t.Namespace != null && t.Namespace.EndsWith(".Messages") && t != typeof(TestEvent));
configure.DefiningEventsAs(t => t == typeof(TestEvent));
configure.UseInMemoryTimeoutPersister();
configure.InMemorySubscriptionStorage();
customConfiguration = new CustomConfiguration();
configure.CustomConfigurationSource(customConfiguration);
Feature.Enable <MessageDrivenSubscriptions>();
configure.Configurer.ConfigureComponent <MessageStore>(DependencyLifecycle.SingleInstance);
return(this);
}
public override void Configure(CustomConfiguration conf, CustomTarget target)
{
base.Configure(conf, target);
conf.SetLib();
//Settings
conf.IncludePaths.Add(SourceRootPath);
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
if (!optionsBuilder.IsConfigured)
{
IConfiguration builder = CustomConfiguration.GetConfiguration();
optionsBuilder.UseSqlServer(builder.GetConnectionString("name=ConnectionStrings:SchedulerConnection"));
}
}
public InMemoryService(IOptions <CustomConfiguration> customConfig, TsvHandler tsvHandler)
{
this.customConfig = customConfig.Value;
this.tsvHandler = tsvHandler;
InitMemory(true);
//todo - add an hourly refresh
}
public override void Configure(CustomConfiguration conf, CustomTarget target)
{
base.Configure(conf, target);
conf.SetLib();
conf.Options.Add(Options.Vc.General.WarningLevel.Level0);
conf.IncludePaths.Add(SourceRootPath);
}
public UserController(IOptions <CustomConfiguration> customConfiguration)
{
_customConfiguration = customConfiguration.Value;
_usersService = Environment.GetEnvironmentVariable(Constants.UsersMicroserviceEnv) ?? _customConfiguration.Services.Users;
_reservationService = Environment.GetEnvironmentVariable(Constants.ReservationMicroserviceEnv) ?? _customConfiguration.Services.Reservation;
_billingService = Environment.GetEnvironmentVariable(Constants.BillingMicroserviceEnv) ?? _customConfiguration.Services.Billing;
_bikesService = Environment.GetEnvironmentVariable(Constants.BikesMicroserviceEnv) ?? _customConfiguration.Services.Bikes;
}
public PatientDailyStatusService(thandizoContext context
, IBusControl bus,
CustomConfiguration customConfiguration)
{
_context = context;
_bus = bus;
_customConfiguration = customConfiguration;
}
public SqlServerModelConfiguration(
[NotNull] IModel model,
[NotNull] CustomConfiguration customConfiguration,
[NotNull] IRelationalAnnotationProvider extensionsProvider,
[NotNull] CSharpUtilities cSharpUtilities,
[NotNull] ModelUtilities modelUtilities)
: base(model, customConfiguration, extensionsProvider, cSharpUtilities, modelUtilities)
{
}
public static void RunWebHost(
CustomConfiguration Configure
, string DatabaseSchema = null
, ushort DatabaseVersion = 1
, string HttpsCertificateFile = null
, string HttpsCertificateHash = null
, ushort HttpRedirectionPort = 0
, ushort Port = 5757
, string WwwRoot = @"./www"
, string TerminalConfigFile = @"./www/terminal/config.js"
, string LogsPath = @"./logs"
, uint SessionTimeOut = 15
)
{
if (m_Host != null)
{
throw new ApplicationException("Web host is already started.");
}
if (DatabaseSchema != null && string.IsNullOrWhiteSpace(DatabaseSchema))
{
throw new ArgumentNullException(nameof(DatabaseSchema));
}
if (DatabaseVersion <= 0)
{
throw new ArgumentOutOfRangeException(nameof(DatabaseVersion));
}
if (string.IsNullOrWhiteSpace(WwwRoot))
{
throw new ArgumentOutOfRangeException(nameof(WwwRoot));
}
if (string.IsNullOrWhiteSpace(TerminalConfigFile))
{
throw new ArgumentOutOfRangeException(nameof(TerminalConfigFile));
}
if (string.IsNullOrWhiteSpace(LogsPath))
{
throw new ArgumentOutOfRangeException(nameof(LogsPath));
}
if (Port <= 0)
{
throw new ArgumentOutOfRangeException(nameof(Port));
}
if (SessionTimeOut <= 0)
{
throw new ArgumentOutOfRangeException(nameof(SessionTimeOut));
}
if (!string.IsNullOrWhiteSpace(HttpsCertificateFile) && string.IsNullOrWhiteSpace(HttpsCertificateHash))
{
throw new ArgumentNullException(nameof(HttpsCertificateHash));
}
m_Host = CreateWebHost(Configure, DatabaseSchema, DatabaseVersion, HttpsCertificateFile, HttpsCertificateHash, HttpRedirectionPort, Port, WwwRoot, TerminalConfigFile, LogsPath, SessionTimeOut);
m_Host.Start();
}
public override void Configure(CustomConfiguration conf, CustomTarget target)
{
base.Configure(conf, target);
conf.SetLib();
//Dependencies
conf.AddPrivateDependency <ThirdParty.STBImage>(target);
conf.AddPrivateDependency <Platform>(target);
}
public override void Configure(CustomConfiguration conf, CustomTarget target)
{
base.Configure(conf, target);
conf.SetLib();
//Dependencies
conf.AddPrivateDependency <Glad>(target);
//Settings
conf.IncludePaths.Add(SourceRootPath);
}
public override ModelConfiguration CreateModelConfiguration(
IModel model,
CustomConfiguration customConfiguration)
{
return(new CustomModelConfiguration(
this,
model,
customConfiguration,
ExtensionsProvider,
CSharpUtilities,
ScaffoldingUtilities));
}
public static ApiSection Api(this CustomConfiguration config)
{
lock (_lockObjectApi)
{
if (_apiSection == null)
{
_apiSection = new ApiSection();
}
}
return(_apiSection);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.AddEntityFrameworkNpgsql().AddDbContext <thandizoContext>(options =>
options.UseNpgsql(Configuration.GetConnectionString("DatabaseConnection")));
var customConfiguration = new CustomConfiguration
{
EmailTemplate = Path.Combine(Environment.ContentRootPath, "MessageTemplates", "email_self_registration.html"),
SmsTemplate = Path.Combine(Environment.ContentRootPath, "MessageTemplates", "sms_self_registration.txt"),
SmsQueueAddress = string.Concat(Configuration["RabbitMQHost"], "/", Configuration["SmsQueue"]),
EmailQueueAddress = string.Concat(Configuration["RabbitMQHost"], "/", Configuration["EmailQueue"]),
PatientQueueAddress = string.Concat(Configuration["RabbitMQHost"], "/", Configuration["DhisQueue"]),
DailySymptomsQueueAddress = string.Concat(Configuration["RabbitMQHost"], "/", Configuration["DhisDailySymptomsQueue"]),
SourceEmailAddress = Configuration["SourceEmailAddress"],
DailySymptomsEmailSubject = Configuration["DailySymptomsEmailSubject"],
RegistrationEmailSubject = Configuration["RegistrationEmailSubject"]
};
var bus = Bus.Factory.CreateUsingRabbitMq(configure =>
{
var host = configure.Host(new Uri(Configuration["RabbitMQHost"]), h =>
{
h.Username(Configuration["RabbitMQUsername"]);
h.Password(Configuration["RabbitMQPassword"]);
});
});
services.AddSingleton <IPublishEndpoint>(bus);
services.AddSingleton <ISendEndpointProvider>(bus);
services.AddSingleton(bus);
bus.Start();
services.AddDomainServices(customConfiguration);
//Disable automatic model state validation to provide cleaner error messages to avoid default complex object
services.Configure <ApiBehaviorOptions>(options =>
{
options.SuppressModelStateInvalidFilter = true;
});
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo
{
Version = "v1",
Title = "Thandizo Patients API",
Description = "Patients API for Thandizo platform",
Contact = new Microsoft.OpenApi.Models.OpenApiContact {
Name = "COVID-19 Malawi Tech Response", Email = "*****@*****.**", Url = new Uri("https://www.thandizo.mw")
}
});
c.IncludeXmlComments(GetXmlCommentsPath());
});
}
public override void Configure(CustomConfiguration conf, CustomTarget target)
{
base.Configure(conf, target);
conf.SetLib();
//Dependencies
conf.AddPrivateDependency <ThirdParty.Glad>(target);
conf.AddPrivateDependency <ThirdParty.Imgui>(target);
ThirdParty.OpenGL.AddAsDependency(conf, target);
ThirdParty.SFML.AddAsDependency(conf, target);
}
public override void Configure(CustomConfiguration conf, CustomTarget target)
{
base.Configure(conf, target);
conf.SetLib();
//Dependencies
conf.AddPrivateDependency <ThirdParty.Imgui>(target);
conf.AddPrivateDependency <AssetManager>(target);
conf.AddPrivateDependency <Graphics>(target);
conf.AddPrivateDependency <Platform>(target);
}
public void LoadCustomConfig()
{
IDataReader rdr = Database.Instance.ExecuteReader("select PropertyName,PropertyValueString from SecurityAgentConfig where AgentId like @p0", Id);
while (rdr.Read())
{
string propName = Db.DbValueConverter.ToString(rdr["PropertyName"]);
if (CustomConfiguration.ContainsKey(propName))
{
CustomConfiguration[propName] = Db.DbValueConverter.ToString(rdr["PropertyValueString"]);
}
}
rdr.Close();
}
public static ApiDataSection Api(this CustomConfiguration config)
{
lock (_lockObjectApiData)
{
if (_apiDataSection == null)
{
_apiDataSection = ConfigurationManager.GetSection(ApiDataSection.SectionName) as ApiDataSection;
if (_apiDataSection == null)
{
throw new ConfigurationErrorsException(String.Format(ConfigurationMessages.SectionNotFound, ApiDataSection.SectionName));
}
}
}
return(_apiDataSection);
}
public static SharepointSection Sharepoint(this CustomConfiguration config)
{
lock (_lockObjectSharepoint)
{
if (_sharepointSection == null)
{
_sharepointSection = ConfigurationManager.GetSection(SharepointSection.SectionName) as SharepointSection;
if (_sharepointSection == null)
{
throw new ConfigurationErrorsException(String.Format(ConfigurationMessages.SectionNotFound, SharepointSection.SectionName));
}
}
}
return(_sharepointSection);
}
public static ServicesSection Services(this CustomConfiguration config)
{
lock (_lockObjectServices)
{
if (_servicesSection == null)
{
_servicesSection = ConfigurationManager.GetSection(ServicesSection.SectionName) as ServicesSection;
if (_servicesSection == null)
{
_servicesSection = new ServicesSection();
}
}
}
return(_servicesSection);
}
public CustomModelConfiguration(
ConfigurationFactory configurationFactory,
IModel model,
CustomConfiguration customConfiguration,
IRelationalAnnotationProvider annotationProvider,
CSharpUtilities cSharpUtilities,
ScaffoldingUtilities scaffoldingUtilities)
: base(
configurationFactory,
model,
customConfiguration,
annotationProvider,
cSharpUtilities,
scaffoldingUtilities)
{
_configurationFactory = configurationFactory;
}
public void BeginSessionCreatesConnectionAndDelegatesToSessionFactory() {
// assemble
var mockEngine = MakeMockEngine();
var mockProvider = MakeMockDbProviderFactory();
var connection = new Mock<DbConnection>();
mockProvider.Setup(m => m.CreateConnection()).Returns(connection.Object);
var mockSessionFactory = MakeMockSf();
var session = new Mock<ISession>();
mockSessionFactory.Setup(m => m.Create(mockEngine.Object, connection.Object, null, true, false, false))
.Returns(session.Object)
.Verifiable();
var target = new CustomConfiguration(mockEngine.Object, mockProvider.Object, MakeMockMapper().Object, mockSessionFactory.Object);
// act
var actual = target.BeginSession();
// assert
Assert.Equal(session.Object, actual);
mockEngine.Verify();
mockSessionFactory.Verify();
}
public void EmptyConfigurationReturnsEmptyMaps() {
var target = new CustomConfiguration(MakeMockMapper().Object);
Assert.Empty(target.Maps);
}
