public override bool TryGetNodeDetail(out NodeDetail nodeDetail)
{
NodeDetail thisNodeDetail;
bool sucess;
List <object> childernNaames = new List <object>();
string[] childPathChunks = new string[this.PathChunks.Length - 1];
Array.Copy(this.PathChunks, 1, childPathChunks, 0, this.PathChunks.Length - 1);
switch (PathChunks[0].ToLower())
{
case ProviderUtil.DATABASES:
DatabaseConfigurations databasees = ((ClusterConfiguration)Configuration).Databases;
thisNodeDetail = new DatabasesDetail(PathChunks[0], databasees, childPathChunks);
sucess = true;
break;
default:
thisNodeDetail = new EndNodeDetail();
sucess = false;
break;
}
if (PathChunks.Length == 1)
{
nodeDetail = thisNodeDetail;
return(sucess);
}
return(thisNodeDetail.TryGetNodeDetail(out nodeDetail));
}
public void Deserialize(Common.Serialization.IO.CompactReader reader)
{
Name = reader.ReadObject() as string;
DisplayName = reader.ReadObject() as string;
Deployment = reader.ReadObject() as DeploymentConfiguration;
Databases = reader.ReadObject() as DatabaseConfigurations;
UID = reader.ReadObject() as string;
}
private static void AddUnitOfWork(IServiceCollection services, DatabaseConfigurations dbConfigs)
{
services.AddDbContext <DataBaseContext>(options =>
{
if (dbConfigs.InMemoryMode)
{
options.UseInMemoryDatabase("DBInMemory");
}
else
{
options.UseSqlServer(dbConfigs.ConnectionString);
}
//Use this to debug client evaluations
options.ConfigureWarnings(warnings => warnings.Throw(RelationalEventId.QueryClientEvaluationWarning));
});
services.AddScoped <IUnitOfWork, UnitOfWork <DataBaseContext> >();
services.AddScoped <IRepository <Dummy>, DummyRepository>();
services.AddScoped <IRepository <Candidate>, CandidateRepository>();
services.AddScoped <IRepository <Postulant>, PostulantRepository>();
services.AddScoped <IRepository <Stage>, ProcessStageRepository>();
services.AddScoped <IRepository <HrStage>, HrStageRepository>();
services.AddScoped <IRepository <TechnicalStage>, TechnicalStageRepository>();
services.AddScoped <IRepository <ClientStage>, ClientStageRepository>();
services.AddScoped <IRepository <OfferStage>, OfferStageRepository>();
services.AddScoped <IRepository <Skill>, SkillRepository>();
services.AddScoped <IRepository <StageItem>, StageItemRepository>();
services.AddScoped <IRepository <Process>, ProcessRepository>();
services.AddScoped <IRepository <Consultant>, ConsultantRepository>();
services.AddScoped <IRepository <User>, UserRepository>();
services.AddScoped <IRepository <SkillType>, SkillTypeRepository>();
services.AddScoped <IRepository <Task>, TaskRepository>();
services.AddScoped <IRepository <TaskItem>, TaskItemRepository>();
services.AddScoped <IRepository <HireProjection>, HireProjectionRepository>();
services.AddScoped <IRepository <EmployeeCasualty>, EmployeeCasualtyRepository>();
services.AddScoped <IRepository <Reservation>, ReservationRepository>();
services.AddScoped <IRepository <Room>, RoomRepository>();
services.AddScoped <IRepository <Office>, OfficeRepository>();
services.AddScoped <IRepository <Employee>, EmployeeRepository>();
services.AddScoped <IRepository <DaysOff>, DaysOffRepository>();
services.AddScoped <IRepository <CompanyCalendar>, CompanyCalendarRepository>();
services.AddScoped <IRepository <Role>, RoleRepository>();
services.AddScoped <IStageItemRepository, StageItemRepository>();
services.AddScoped <IProcessStageRepository, ProcessStageRepository>();
services.AddScoped <IProcessRepository, ProcessRepository>();
services.AddScoped <IHrStageRepository, HrStageRepository>();
services.AddScoped <ITechnicalStageRepository, TechnicalStageRepository>();
services.AddScoped <IClientStageRepository, ClientStageRepository>();
services.AddScoped <IOfferStageRepository, OfferStageRepository>();
services.AddScoped <IRepository <Community>, CommunityRepository>();
services.AddScoped <IRepository <CandidateProfile>, CandidateProfileRepository>();
services.AddTransient <IMigrator, SeedMigrator>();
}
public static IServiceCollection AddDomain(this IServiceCollection services, DatabaseConfigurations dbConfigs)
{
AddUnitOfWork(services, dbConfigs);
AddExternalServices(services);
AddServices(services);
services.AddAutoMapper();
return(services);
}
public DocumentDbFixture()
{
_client = DocumentClientFactory.CreateDocumentClientAsync(DocumentClientSettings.Emulator).Result;
var script = new SimpleUptimeDbScript(_client, DatabaseConfigurations.Create());
script.DropDatabaseAsync().Wait();
script.ExecuteMigration().Wait();
_documentHelper = new DocumentHelper(_client);
}
public static SqlInstance CreateCustomDatabase(string DatabaseName)
{
SqlInstance instance = new SqlInstance();
instance.CreateDatabase(DatabaseName);
instance.SetDatabase(DatabaseName);
DatabaseConfiguration dbConfig = DatabaseConfigurations.SqlPersistenceConfiguration(InstanceStoreVersion.Version45);
instance.ExecuteSqlFile(dbConfig.CreateSchema);
instance.ExecuteSqlFile(dbConfig.CreateLogic);
return(instance);
}
public Startup(IConfiguration configuration, IHostingEnvironment hostingEnvironment)
{
Configuration = configuration;
_hostingEnvironment = hostingEnvironment;
DatabaseConfigurations = new DatabaseConfigurations(
Configuration.GetValue("InMemoryDatabase", true) && hostingEnvironment.CanModifyScheme(),
Configuration.GetValue("RunMigrations", false) && hostingEnvironment.CanModifyScheme(),
Configuration.GetValue("RunSeed", false) && hostingEnvironment.CanModifyScheme(),
Configuration.GetConnectionString("SeedDB")
);
}
public AccountDac(DatabaseConfigurations config)
{
var settings = MongoClientSettings.FromUrl(new MongoUrl(config.MongoDBConnection));
settings.SslSettings = new SslSettings()
{
EnabledSslProtocols = SslProtocols.Tls12
};
var mongoClient = new MongoClient(settings);
var database = mongoClient.GetDatabase(config.DatabaseName);
Collection = database.GetCollection <Account>("Account");
}
public Startup(IConfiguration configuration, IHostingEnvironment env)
{
Configuration = configuration;
_env = env;
DatabaseConfigurations = new DatabaseConfigurations(
Configuration.GetValue("InMemoryDatabase", true) && env.CanModifyScheme(),
Configuration.GetValue("RunMigrations", false) && env.CanModifyScheme(),
Configuration.GetValue("RunSeed", false) && env.CanModifyScheme(),
Configuration.GetConnectionString("SeedDB")
);
UseTestingAuthentication = Configuration.GetValue("UseTestAuthentication", false);
}
public static void RegisterServices(IServiceCollection services)
{
// serivces
services.AddTransient <Settings>();
services.AddTransient <IHttpMonitorRepository, HttpMonitorDocumentRepository>();
services.AddTransient <IHttpMonitorCheckRepository, HttpMonitorCheckDocumentRepository>();
services.AddSingleton <IDocumentClient>(provider => DocumentClientFactory.CreateDocumentClientAsync(provider.GetService <Settings>().ConnectionStrings.CosmosDb).Result);
services.AddTransient <DatabaseConfigurations>(_ => DatabaseConfigurations.Create());
services.AddTransient <SimpleUptimeDbScript>();
services.AddTransient <ICheckHttpEndpointPublisher, CheckHttpEndpointQueuePublisher>();
services.AddTransient <IHttpEndpointCheckedPublisher, HttpEndpointCheckedQueuePublisher>();
services.AddTransient <IHttpMonitorCheckedPublisher, HttpMonitorCheckedQueuePublisher>();
services.AddTransient <JsonSerializer>(provider =>
{
var settings = new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
TypeNameHandling = TypeNameHandling.Objects,
TypeNameAssemblyFormat = FormatterAssemblyStyle.Full
};
settings.Converters.Add(new GuidValueJsonConverter());
settings.Converters.Add(new HttpMethodJsonConverter());
return(JsonSerializer.Create(settings));
});
services.AddTransient <ICheckHttpMonitorPublisherService, CheckHttpMonitorPublisherService>();
services.AddTransient <CloudStorageAccount>(provider => CloudStorageAccount.Parse(provider.GetService <Settings>().ConnectionStrings.StorageAccount));
services.AddTransient <CloudQueueClient>(provider => provider.GetService <CloudStorageAccount>().CreateCloudQueueClient());
services.AddTransient <IHttpMonitorExecutor, HttpMonitorExecutor>();
services.AddSingleton <HttpClient>();
services.AddTransient <CloudQueueFactory>();
services.AddTransient <CreateCloudQueueAsync>(provider =>
provider.GetService <CloudQueueFactory>().CreateCloudQueueAsync);
services.AddTransient <IHttpMonitorService, HttpMonitorService>();
services.AddSingleton <JsonMediaTypeFormatter>(_ => new JsonMediaTypeFormatter
{
SerializerSettings = Constants.JsonSerializerSettings
});
}
public WebApiAppFixture()
{
_client = DocumentClientFactory.CreateDocumentClientAsync(DocumentClientSettings.Emulator).Result;
_documentHelper = new DocumentHelper(_client);
new SimpleUptimeDbScript(_client, DatabaseConfigurations.Create())
.DropDatabaseAsync()
.Wait();
_server = new TestServer(new WebHostBuilder()
.UseStartup <Startup>());
HttpClient = _server.CreateClient();
}
public override bool TryGetNodeDetail(out NodeDetail nodeDetail)
{
NodeDetail thisNodeDetail;
bool sucess;
List <object> childernNaames = new List <object>();
string[] childPathChunks = new string[this.PathChunks.Length - 1];
Array.Copy(this.PathChunks, 1, childPathChunks, 0, this.PathChunks.Length - 1);
switch (PathChunks[0].ToLower())
{
case ProviderUtil.SHARDS:
DeploymentConfiguration deployment = ((ClusterConfiguration)Configuration).Deployment;
thisNodeDetail = new ShardsDetail(PathChunks[0], deployment, childPathChunks);
sucess = true;
break;
case ProviderUtil.DATABASES:
DatabaseConfigurations databasees = ((ClusterConfiguration)Configuration).Databases;
thisNodeDetail = new DatabasesDetail(PathChunks[0], databasees, childPathChunks);
sucess = true;
break;
case ProviderUtil.CONFIGCLUSTER:
thisNodeDetail = new ConfigurationNodesDetail(PathChunks[0], true, true,
new ConfigClusterInfo(ConfigurationConnection.ConfigCluster), childPathChunks);
sucess = true;
break;
default:
thisNodeDetail = null;
sucess = false;
break;
}
if (PathChunks.Length == 1)
{
nodeDetail = thisNodeDetail;
return(sucess);
}
return(thisNodeDetail.TryGetNodeDetail(out nodeDetail));
}
internal DatabasesDetail(string nodeName, DatabaseConfigurations configuration, string[] pathChunks)
{
NodeName = nodeName;
NodeType = PathType.Databases;
IsContainer = true;
IsValid = true;
Configuration = configuration;
PathChunks = pathChunks;
ChilderanTable = new PrintableTable();
ChilderanTable.AddHeader("Database name", "Provider");
ChilderanName = new List <string>();
foreach (var db in configuration.Configurations.Values)
{
ChilderanName.Add(db.Name);
ChilderanTable.AddRow(db.Name, db.Storage.StorageProvider.StorageProviderType.ToString());
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
DatabaseConfigurations connectionString = Configuration.GetSection("ConnectionStrings")
.Get <DatabaseConfigurations>();
EmailConfiguration emailConfiguration = Configuration.GetSection("EmailConfiguration")
.Get <EmailConfiguration>();
CacheConfiguration cacheConfiguration = Configuration.GetSection("CacheConfiguration")
.Get <CacheConfiguration>();
if (cacheConfiguration.IsEnabled)
{
services.AddStackExchangeRedisCache(options => options.Configuration = cacheConfiguration.ConnectionString);
services.AddSingleton <IResponseCacheService, ResponseCacheService>();
}
CloudConfiguration cloudConfiguration = Configuration.GetSection("CLOUDINARY")
.Get <CloudConfiguration>();
services.AddSingleton(cacheConfiguration);
services.AddSingleton(emailConfiguration);
services.AddSingleton(connectionString);
services.AddSingleton(cloudConfiguration);
services.AddTransient <IDBContext, DBContext>();
services.AddScoped <IUserService, UserService>();
services.AddScoped <IUserRepository, UserRepository>();
services.AddScoped <ITokenManager, TokenManager>();
services.AddScoped <IBooksRepository, BooksRepository>();
services.AddScoped <IBookService, BookService>();
services.AddScoped <IWishlistRepository, WishlistRepository>();
services.AddScoped <IWishlistService, WishlistService>();
services.AddScoped <ICartRepository, CartRepository>();
services.AddScoped <ICartService, CartService>();
services.AddScoped <IOrderRepository, OrderRepository>();
services.AddScoped <IOrderService, OrderService>();
services.AddScoped <IEmailSender, EmailSender>();
services.AddScoped <IMqServices, MsmqServices>();
services.AddScoped <IEmailItemDetails, EmailItemDetails>();
services.AddScoped <ICacheRepository, CacheRepository>();
services.AddScoped <IAddressRepository, AddressRepository>();
services.AddScoped <IAddressService, AddressService>();
services.AddScoped <ICloudService, CloudService>();
services.AddAutoMapper(typeof(Startup));
services.AddSwagger();
services.AddCors();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc(options =>
{
// model binders
options.ModelBinderProviders.Insert(0, new HttpMonitorIdBinder());
})
// mvc json settings
.AddJsonOptions(opt =>
{
opt.SerializerSettings.Converters.Add(new GuidValueJsonConverter());
opt.SerializerSettings.Converters.Add(new HttpMethodJsonConverter());
});
services.Configure <RouteOptions>(options =>
{
// route constraints
options.ConstraintMap.Add(HttpMonitorIdRouteConstraint.RouteLabel, typeof(HttpMonitorIdRouteConstraint));
});
services.Configure <MvcOptions>(options =>
{
options.Filters.Add(new CorsAuthorizationFilterFactory("AllowAnyOrigin"));
});
services.AddCors(options =>
{
options.AddPolicy("AllowAnyOrigin", builder => builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader());
});
// settings
services.AddOptions();
services.Configure <DocumentClientSettings>(Configuration.GetSection("DocumentClientSettings"));
// serivces
services.AddTransient <IHttpMonitorService, HttpMonitorService>();
services.AddTransient <IHttpMonitorRepository, HttpMonitorDocumentRepository>();
services.AddSingleton <IDocumentClient>(provider => DocumentClientFactory.CreateDocumentClientAsync(Configuration.GetConnectionString("CosmosDb")).Result);
services.AddTransient <DatabaseConfigurations>(_ => DatabaseConfigurations.Create());
services.AddTransient <SimpleUptimeDbScript>();
services.AddTransient <IHttpMonitorExecutorService, HttpMonitorExecutorService>();
services.AddTransient <IHttpMonitorExecutor, HttpMonitorExecutor>();
services.AddSingleton <HttpClient>();
}
public CheckHttpMonitorPublisherServiceTests(DocumentDbFixture fixture)
{
_fixture = fixture;
_repository = new HttpMonitorDocumentRepository(fixture.DocumentClient, DatabaseConfigurations.Create());
var connectionString = "UseDevelopmentStorage=true";
var storageAccount = CloudStorageAccount.Parse(connectionString);
var queueClient = storageAccount.CreateCloudQueueClient();
_queue = queueClient.GetQueueReference(nameof(CheckHttpEndpointQueuePublisherTests).ToLowerInvariant());
_queue.CreateIfNotExistsAsync().Wait();
var publisher = new CheckHttpEndpointQueuePublisher(name => Task.FromResult(_queue));
_service = new CheckHttpMonitorPublisherService(_repository, publisher);
}
public bool Initialize(DatabaseConfigurations configurations, NodeContext context, IDictionary <String, IDictionary <String, IDistribution> > distributionMaps)
{
_distributionMap = distributionMaps;
foreach (DatabaseConfiguration dbConfig in configurations.Configurations.Values)
{
lock (_databases)
{
if (!_databases.ContainsKey(dbConfig.Name))
{
IDatabaseStore dbStore = new DatabaseStore();
IDictionary <string, IDistribution> colDistributions;
_distributionMap.TryGetValue(dbConfig.Name, out colDistributions);
if (((DatabaseStore)dbStore).Initialize(dbConfig, context, colDistributions))
{
_databases.Add(dbConfig.Name, dbStore);
}
}
}
}
return(true);
}
public void Migrate(DatabaseConfigurations dbConfig)
{
var isDatabaseModified = false;
if (dbConfig.RunMigrations)
{
//_context.Database.Migrate();
_context.Database.EnsureDeleted();
_context.Database.EnsureCreated();
isDatabaseModified = true;
}
if (dbConfig.RunSeed)
{
SeedData(_context);
isDatabaseModified = true;
}
if (isDatabaseModified)
{
_context.SaveChanges();
_context.Dispose();
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllersWithViews();
// In production, the React files will be served from this directory
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = "ClientApp/build";
});
var connectionstring = DatabaseConfigurations.DatabaseConnectionString(_hostEnvironment, Configuration);
services.AddDbContext <DataContext>(options => options.UseNpgsql(connectionstring));
services.AddIdentityConfiguring();
services.DInjections();
services.AddConfigureSettings(Configuration);
services.AddCors();
services.UseJWTAuthentication();
services.AddSignalR();
services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());
}
public HttpMonitorDocumentRepositoryTests(DocumentDbFixture fixture)
{
_fixture = fixture;
_repository = new HttpMonitorDocumentRepository(fixture.DocumentClient, DatabaseConfigurations.Create());
}
public AlertContactDocumentRepositoryTests(DocumentDbFixture fixture)
{
_fixture = fixture;
_repository = new AlertContactDocumentRepository(fixture.DocumentClient, DatabaseConfigurations.Create());
}
