public async Task RecordBounces(Server oServer, StreamWriter oWriter) { var oPostmarkRestApiClient = new PostmarkRestApiClient(oServer.APIToken); var sBounceJson = oPostmarkRestApiClient.GetBounces(oServer.MaxBounces); JToken oJToken = JToken.Parse(sBounceJson); var lstBouncedMails = new List <BouncedMail>(); foreach (var oChildJToken in oJToken.SelectToken("Bounces")) { lstBouncedMails.Add(new BouncedMail(oChildJToken)); } int iTotalBounces = lstBouncedMails.Count(); DateTime?dtLatestBounce = lstBouncedMails.Any() ? lstBouncedMails.Max(oBouncedMail => oBouncedMail.BounceDate) : (DateTime?)null; string sTimestamp = dtLatestBounce.HasValue ? $"; latest @ {dtLatestBounce.Value.ToDateFormatted()}" : String.Empty; string sLog = $" - Server: {oServer.Name}|| # {iTotalBounces.ToString("#,##0")} bounces{sTimestamp}"; Console.WriteLine(sLog); oWriter.WriteLine(sLog); var oServerRepository = new ServerRepository(); lstBouncedMails.ToList().ForEach(async oBouncedMail => await oServerRepository.RecordBounce(oServer.Key, oBouncedMail.MessageID, oBouncedMail.BounceType, oBouncedMail.Description, oBouncedMail.Detail, oBouncedMail.SendTo, oBouncedMail.SendFrom, oBouncedMail.BounceDate, oBouncedMail.Subject, oWriter)); }
public void GivenFieldBOfTheRecordR0HasBeenChangedOnTheServer() { var r0 = ServerRepository.Find(TestItemR0.Id); r0.FieldB = FieldBServerChangedValue = Guid.NewGuid().ToString(); ServerRepository.Update(r0); }
public void ThenTheServerR0RecordShouldHaveClientValueInFieldAAndServerValueInFieldB() { var r0 = ServerRepository.Find(TestItemR0.Id); Assert.AreEqual(FieldAClientChangedValue, r0.FieldA); Assert.AreEqual(FieldBServerChangedValue, r0.FieldB); }
public void GivenTheR0RecordExistsOnTheServer() { if (ServerRepository.Find(TestItemR0.Id) == null) { ServerRepository.Insert(TestItemR0); } }
public void GivenTheRecordR1DoesNotExistOnTheServer() { if (ServerRepository.Find(TestItemR1.Id) != null) { ServerRepository.Delete(TestItemR1.Id); } }
private void SetupSync() { // Set up client ILog clientLogger = LogManager.GetLogger("Client"); log4net.Config.XmlConfigurator.Configure(clientLogger.Logger.Repository); ClientContainer.Register <ILog>(clientLogger); ClientContainer.Register <IRepository <TestItem, Guid> >(ClientRepository); ClientContainer.Register <ISyncResult <TestItem, Guid>, SyncResult <TestItem, Guid> >(); ClientContainer.Register <IReplica>(new Replica("Client")); // Set up server ILog serverLogger = LogManager.GetLogger("Server"); log4net.Config.XmlConfigurator.Configure(serverLogger.Logger.Repository); ServerContainer.Register <ILog>(clientLogger); ServerContainer.Register <IRepository <TestItem, Guid> >(ServerRepository); ServerContainer.Register <ISyncResult <TestItem, Guid>, SyncResult <TestItem, Guid> >(); ServerContainer.Register <IReplica>(ServerReplica); ServerRepository.Insert(TestItemR0); // Start with an item on the server // Used for both client and server Container.Register <ISyncConflictResolver <TestItem, Guid>, TestItemConflictResolver>(); // Just pass the sync requests directly between the server and client // Ordinarily these would by serialized and sent over a wire, but the // TestSyncRequestSender, just passes the object directly. ClientContainer.Register <ISyncRequestSender <TestItem, Guid> >(new TestSyncRequestSender <TestItem, Guid>(ServerSendingSynchronizer)); ClientSendingSynchronizer.BeginSync(ServerReplica); }
protected void OnFavouriteStatusChanged() { ServerModel.IsFavourite = !ServerModel.IsFavourite; ServerModel.FavouriteSince = DateTime.Now.AddHours(1); ServerRepository.Update(ServerModel); FavouriteStatusChanged.InvokeAsync(""); }
public async Task OneTimeSetup() { var hourRepo = new HourRepository(ConnectionFactorySetup.ConnectionFactory); this.metricRepository = new MetricRepository(ConnectionFactorySetup.ConnectionFactory); var serverRepository = new ServerRepository(ConnectionFactorySetup.ConnectionFactory); this.server = await serverRepository.CreateAsync(new Server { ServerName = Environment.MachineName, CreatedOn = DateTime.Now, DeletedOn = null, ServerTypeId = 3, ServerIpAddress = "127.0.0.1", IgnoreServer = false, ResponsibleAgent = "", ArtifactId = 1234, }); hour = await hourRepo.CreateAsync(new Hour { HourTimeStamp = DateTime.Now.NormilizeToHour() }); metric = await this.metricRepository.CreateAsync(new Metric { HourId = hour.Id, MetricType = MetricType.WebUptime }); this.metricDataRepository = new MetricDataRepository(ConnectionFactorySetup.ConnectionFactory); metricData = await this.metricDataRepository.CreateAsync(new MetricData { MetricId = metric.Id, Score = 100.0m }); metricData.Score = 75.0m; metricData.Data = "asdf"; await this.metricDataRepository.UpdateAsync(metricData); metricData = await this.metricDataRepository.ReadAsync(metricData.Id); }
public override Response Execute() { // If we're already initialized (Test path) if (this.postInstallService != null) { return(this.ExecutePdb()); } var logger = new TextLogger(); var connectionFactory = new HelperConnectionFactory(this.Helper); var agentRepository = new AgentRepository(connectionFactory); var agentManager = this.Helper.GetServicesManager().CreateProxy <IAgentManager>(ExecutionIdentity.System); var agentManagerService = new AgentManagerService(agentManager, agentRepository, logger); var textLogger = new TextLogger(); var resourceServerRepository = new ResourceServerRepository(connectionFactory); var refreshServerService = new RefreshServerService(textLogger, resourceServerRepository); var serverRepository = new ServerRepository(connectionFactory); var configurationRepository = new ConfigurationRepository(connectionFactory); this.postInstallService = new PostInstallService(agentManagerService, refreshServerService, serverRepository, configurationRepository, logger); var response = this.ExecutePdb(); agentManager?.Dispose(); return(response); }
public async Task Server_ReadWorkspaceIds() { var repo = new ServerRepository(connectionFactory); var result = await repo.ReadServerWorkspaceIdsAsync(server.ServerId); Assert.Pass($"Workspaces on Server {server.ServerId}: Count={result.Count}, {string.Join(", ", result)}"); }
public ActionResult ServerList(FormCollection formCollection) { var token = formCollection["token"]; var loginRepo = new LoginRepository(); var serversRepo = new ServerRepository(); if (loginRepo.IsTokenExists(token)) { var servers = serversRepo.GetServers(1); var responce = new ServerListResponce(); responce.Servers = new List <ServerInfo>(); foreach (var server in servers) { responce.Servers.Add(new ServerInfo { ServerName = server.Name, ServerAddress = server.Address, UsersCount = server.UsersCount }); } var ms = new MemoryStream(); Serializer.Serialize(ms, responce); ms.Position = 0; return(new FileStreamResult(ms, "application/octet-stream")); } return(new EmptyResult()); }
public async Task Setup() { connectionFactory = TestUtilities.GetIntegrationConnectionFactory(); var repo = new ServerRepository(connectionFactory); server = await repo.CreateAsync(new Server { ServerName = Environment.MachineName, CreatedOn = DateTime.Now, DeletedOn = null, ServerTypeId = 3, ServerIpAddress = "127.0.0.1", IgnoreServer = false, ResponsibleAgent = "", ArtifactId = 1234, LastChecked = null, UptimeMonitoringResourceHost = null, UptimeMonitoringResourceUseHttps = null, LastServerBackup = null, AdminScriptsVersion = null, }); server.UptimeMonitoringResourceHost = UpdatedHost; await repo.UpdateAsync(server); }
public async Task SetUp() { var connFactory = TestUtilities.GetIntegrationConnectionFactory(); this.searchAuditBatchRepository = new SearchAuditBatchRepository(connFactory); var hourRepo = new HourRepository(connFactory); hour = await hourRepo.CreateAsync(new Hour { HourTimeStamp = DateTime.UtcNow.NormilizeToHour() }); Assert.That(hour, Is.Not.Null, "Must have a valid hour for tests"); var serverRepo = new ServerRepository(connFactory); server = (await serverRepo.ReadAllActiveAsync()).FirstOrDefault(); Assert.That(server, Is.Not.Null, "Must have a valid server for tests"); this.HourAuditSearchBatchId = await this.searchAuditBatchRepository.CreateHourSearchAuditBatch(hour.Id, server.ServerId, 1); await this.searchAuditBatchRepository.CreateBatches(new[] { new SearchAuditBatch { HourSearchAuditBatchId = this.HourAuditSearchBatchId, WorkspaceId = Config.WorkSpaceId, BatchStart = 0, BatchSize = 5000 } }); this.searchAuditBatch = (await this.searchAuditBatchRepository.ReadBatchesByHourAndServer(hour.Id, server.ServerId)).FirstOrDefault(); }
private string GetUrlFromServer(string gServerID) { IQueryable <AUTH_SERVER> query = ServerRepository.GetQueryable(); var system = query.Single(s => s.SERVER_ID == gServerID); return(system.URL); }
public async Task <List <Server> > List() { var oServerRepository = new ServerRepository(); IDataReader oDataReader = null; try { oDataReader = await oServerRepository.List(); } catch (Exception) { throw; } var lstServers = new List <Server>(); while (oDataReader.Read()) { var oServer = new Server(oDataReader); lstServers.Add(oServer); } oDataReader.Close(); return(lstServers); }
public ServerService() { _serverRepository = new ServerRepository(); _gameModeRepository = new GameModeRepository(); _matchRepository = new MatchRepository(); _utilRepository = new UtilRepository(); }
public void Test1() { _server_api = new OpenServerApi("./server_information.json"); _server_mapper = new ServerEntityMapper(); _server_repository = new ServerRepository(_server_api, _server_mapper); _server_creator = new ServerCreatorRequest(_server_repository); _server_activator = new ServerActivatorRequest(_server_repository); ServerEntity server = _server_creator.Handle(666); Assert.IsNotNull(server); Assert.AreEqual(666, server.Port); ServerEntity server2 = _server_creator.Handle(667); Assert.IsNotNull(server2); Assert.AreEqual(667, server2.Port); Assert.AreEqual(666, server.Port); Assert.AreNotSame(server, server2); server = _server_activator.Handle(server, true, new ServerAcceptCallback(server)); Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); socket.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 666)); Assert.AreEqual(true, socket.Connected); Assert.AreEqual(true, server.IsRunning); Assert.AreEqual(false, server2.IsRunning); server = _server_activator.Handle(server, false, null); Assert.AreEqual(false, server.IsRunning); }
private string GetUrlFromServer(Guid gServerID) { IQueryable <THOK.Authority.DbModel.Server> query = ServerRepository.GetQueryable(); var system = query.Single(s => s.ServerID == gServerID); return(system.Url); }
public async Task GetAllShouldGetAllServersFromGivenGuild() { Server[] servers = new Server[] { new Server(0, 11u, "127.0.0.1", 123, "test"), new Server(0, 11u, "24.1.2.1", 123, "test2"), new Server(0, 11u, "17.1.0.1", 22, "test3"), new Server(0, 11u, "12.0.2.1", 33, "wara4"), new Server(0, 11u, "12.0.2.1", 11, "wara"), }; IServerRepository repo = new ServerRepository(GetMysql()); foreach (var s in servers) { await repo.AddServer(s.GuildId, s.ServerIp, s.ServerPort, s.ServerName); } await repo.AddServer(12u, "10.0.0.1", 123, "different guild"); await repo.AddServer(13u, "10.0.0.1", 123, "different guild"); var response = await repo.GetAll(11u); foreach (var s in servers) { Assert.NotNull(response.Single(x => x.ServerIp == s.ServerIp && x.ServerName == s.ServerName && x.ServerPort == s.ServerPort)); } }
public object GetServerById(string serverID) { Guid sid = new Guid(serverID); var server = ServerRepository.GetQueryable().FirstOrDefault(s => s.ServerID == sid); return(server.ServerName); }
public void InitializeViewModelExecute() { this.serverRepository = new ServerRepository(); this.settingsRepository = new SettingsRepository(); currentSettings = settingsRepository.GetCurrentSettings(); this.Refresh(); }
public TableItemsResponse Items(TableItemsRequest request) { TableItemsResponse response = new TableItemsResponse(); ServerRepository serverRepository = new ServerRepository(); var serverEntity = serverRepository.GetServer(request.ServerName); if (serverEntity == null) { response.Message = "服务器不存在"; return(response); } OpenDBResult openDBResult = TheReaderBase.GetConnection(serverEntity); if (openDBResult.Status != 0) { response.Status = openDBResult.Status; response.Message = openDBResult.Message; return(response); } using (var conn = openDBResult.Connection) { switch (serverEntity.ServerType) { case ServerTypeConstant.Mysql: { var entityList = MysqlReader.GetTableEntityList(conn as MySqlConnection, serverEntity.MysqlDBName); response.TableList = entityList.Select(v => new SchemaTableVo { Name = v.Name }).ToList(); } break; case ServerTypeConstant.Sqlite: { var entityList = SqliteReader.GetTableEntityList(conn as SQLiteConnection); response.TableList = entityList.Select(v => new SchemaTableVo { Name = v.Name }).ToList(); } break; default: { response.Message = "不支持的数据库类型"; return(response); } } } response.Status = 1; return(response); }
public object GetDetails(string cityID, string serverID) { Guid cityid = new Guid(cityID); Guid serverid = new Guid(serverID); var server = ServerRepository.GetQueryable().Where(s => s.City.CityID == cityid && s.ServerID == serverid).Select(s => s.ServerID); var servers = ServerRepository.GetQueryable().Where(s => !server.Any(sv => sv == s.ServerID) && s.City.CityID == cityid).Select(s => new { s.ServerID, s.ServerName, s.Description, Status = s.IsActive ? "启用" : "禁用" }); return(servers.ToArray()); }
public ServersController(DbContextOptions <ApiContext> options, ILogger <ServersController> logger) { ApiContext ctx = new ApiContext(options); ServerRepository repo = new ServerRepository(ctx); _ctx = ctx; _logger = logger; _repo = repo; }
protected override void OnInitialized() { Servers = ServerRepository.GetList(); ServersLeft = NumberOfServersAllowed - Servers.Count; NumberOfServersOnlineLeft = MaximumAmountOfServersOnline - Servers.Where(s => s.Online).Count(); PrepareServerButtonName(); PrepareServerCreationStatus(); ValidateServerName(); }
public async Task Insert_ShouldBeAbleToInsertSameServersToDifferentGuilds() { IServerRepository repo = new ServerRepository(GetMysql()); // this should not trigger any exception - smoke test await repo.AddServer(12u, "10.0.0.1", 123, "same"); await repo.AddServer(13u, "10.0.0.1", 123, "same"); }
public void UpdateListOfObjects() { var l = ServerRepository.GetAllInventoryObject(); if (l != null) { ListOfObjects = l; } }
public async Task GetAll_ShouldGetServersFromSpecificGuild() { ISubscribedServerRepository repo = new SubscribedServerRepository(GetMysql()); IServerRepository serverRepo = new ServerRepository(GetMysql()); async Task <SubscribedServer> AddServer(SubscribedServer s) { var server = await serverRepo.AddServer(s.Server.GuildId, s.Server.ServerIp, s.Server.ServerPort, s.Server.ServerName); return(await repo.Add(server, s.Port, s.ChannelId)); } var ss = new SubscribedServer[] { new SubscribedServer( new Server(0, 11u, "10.0.0.1", 123, "GetAll_ShouldGetServersFromSpecificGuild"), DateTimeOffset.Now, 100, null, 150 ), new SubscribedServer( new Server(1, 11u, "10.0.5.1", 123, "GetAll_ShouldGetServersFromSpecificGuild2"), DateTimeOffset.Now, 100, null, 150 ), }; var others = new SubscribedServer[] { new SubscribedServer( new Server(0, 15u, "10.0.0.1", 123, "GetAll_ShouldGetServersFromSpecificGuild"), DateTimeOffset.Now, 100, null, 150 ), new SubscribedServer( new Server(1, 18u, "10.0.5.1", 123, "GetAll_ShouldGetServersFromSpecificGuild2"), DateTimeOffset.Now, 100, null, 150 ), }; var toCheck = new List <SubscribedServer>(); foreach (var s in ss) { toCheck.Add(await AddServer(s)); } foreach (var s in others) { await AddServer(s); } var servers = await repo.GetAll(11u); foreach (var s in toCheck) { Assert.NotNull(servers.Single(x => x.ChannelId == s.ChannelId && x.Server.Id == s.Server.Id && x.Server.ServerIp == s.Server.ServerIp)); } }
public async Task UpdatePassword_ShouldChangePassword() { IServerRepository repo = new ServerRepository(GetMysql()); var server = await repo.AddServer(11u, "192.168.0.1", 123, "testServerName"); await repo.UpdatePassword(server.Id, "pwd"); server = await repo.GetServer(11u, server.ServerName); Assert.Equal("pwd", server.ServerPassword); }
public async Task Server_ReadPrimaryStandaloneAsync() { // Arrange var repo = new ServerRepository(connectionFactory); // Act var result = await repo.ReadPrimaryStandaloneAsync(); // Assert Assert.Pass($"Result may differ, current standalone server: {result}"); }