public IActionResult SelectEnhancements(SystemRegistration sr, string Mod_Code)
{
EnhancementSelectionList enhancement_selection_list =
new EnhancementSelectionList(enh_repo, sr, Mod_Code, enh_reg_repository);
return(View(enhancement_selection_list));
}
void PerformRegistrations()
{
IApplicationRegistration applicationRegistration = new ApplicationRegistration("Security Tester");
applicationRegistration
.RegisterComponent(
(new ComponentRegistration <Authentication>(AUTHENTICATION_COMPONENT_NAME, applicationRegistration))
.RegisterObservableEvent(AUTHENTICATION_EVENT_NAME, authentication => new Func <bool>(authentication.Verify))
.RegisterObservableParameter(_isAdminVar.Name, authentication => authentication.AdministratorAccess)
.RegisterObservableParameter(_accessRightsVar.Name, authentication => authentication.AccessRights)
)
.RegisterComponent(
(new ComponentRegistration <SecurityCredential>("Security Credential Component", applicationRegistration))
.RegisterObservableEvent("Credential Setup", securityCredential => new Action <string, string>(securityCredential.SetCredentials))
.RegisterObservableEvent("Credential Input Validation", securityCredential => new Func <bool>(securityCredential.ValidateCredentialInput))
);
ISystemRegistration systemRegistration = new SystemRegistration("Security System");
systemRegistration
.RegisterApplication(applicationRegistration)
.RegisterApplication(new ApplicationRegistration("Dummy Application"));
ActivityManager.GetInstance().RegisterSystem(systemRegistration);
}
public async Task <bool> RegisterSystem(SystemRegistration registration)
{
return(await Task.Run(() =>
{
lock (Sync)
{
if (registration.Id > 0)
{
var storedRegistration = Repo.Read(registration.Id);
if (storedRegistration != null)
{
registration = storedRegistration;
}
}
if (registration.Id < 1)
{
registration.Id = NextId;
NextId++;
}
if (registration.Port == 0)
{
registration.Port = (ushort)Random.Next(5000, 65000);
}
if (registration.IpAddress == null)
{
registration.IpAddress = UseLocalHost
? IpAddress.LocalHost
: (IpAddress) new byte[] { Subnet[0], Subnet[1], Subnet[2], (byte)NextIp };
}
Logger?.WriteLine($"System Registration: Id = {registration.Id}, Name = {registration.Name} ");
var createdregistration = Repo.Create(registration);
return true;
}
}));
}
public void Initialize()
{
IApplicationRegistration applicationRegistration = new ApplicationRegistration("Security Tester");
applicationRegistration
.RegisterComponent(
(new ComponentRegistration <Authentication>("Authentication Component", applicationRegistration))
.RegisterObservableEvent("Validation", authentication => new Func <bool>(authentication.Verify))
.RegisterObservableParameter("Is Administrator", authentication => authentication.AdministratorAccess)
.RegisterObservableParameter("Access Rights", authentication => authentication.AccessRights)
)
.RegisterComponent(
(new ComponentRegistration <SecurityCredential>("Security Credential Component", applicationRegistration))
.RegisterObservableEvent("Credential Setup", securityCredential => new Action <string, string>(securityCredential.SetCredentials))
.RegisterObservableEvent("Credential Input Validation", securityCredential => new Func <bool>(securityCredential.ValidateCredentialInput))
);
ISystemRegistration systemRegistration = new SystemRegistration("Security System");
systemRegistration
.RegisterApplication(applicationRegistration)
.RegisterApplication(new ApplicationRegistration("Dummy Application"));
ActivityManager.GetInstance().RegisterSystem(systemRegistration);
}
public ActionResult GetNext(SystemRegistration sr)
{
ModelState.Clear();
return(View(nameof(Index), sys_reg_repository.MoveNext(sr.Syr_Cst_Code,
sr.Syr_Sys_Code,
sr.Syr_Ver_Code)));
}
public ViewResult GetPrev(SystemRegistration sr)
{
ModelState.Clear();
var model = sys_reg_repository.MovePrev(sr.Syr_Cst_Code, sr.Syr_Sys_Code, sr.Syr_Ver_Code);
SetKey(model.Syr_Cst_Code, model.Syr_Sys_Code, model.Syr_Ver_Code);
return(View(nameof(Index), model));
}
public IActionResult SystemRegistrationForm(SystemRegistration sr)
{
if (ModelState.IsValid)
{
sys_reg_repository.AddSystemRegistration(sr);
ModelState.Clear();
}
return(RedirectToAction(nameof(Index)));
}
public ViewResult SearchCustomer(SystemRegistration sr)
{
ViewBag.ControllerName = "SystemRegistration";
if (string.IsNullOrWhiteSpace(sr.Syr_Cst_Code))
{
return(View(cst_repo.Customers));
}
return(View(cst_repo.Customers.Where(r => r.Cst_Code.Contains(sr.Syr_Cst_Code))));
}
public IActionResult SystemRegForm(SystemRegistration sr, string mod_code, string cur_tab)
{
SetKey(sr.Syr_Cst_Code, sr.Syr_Sys_Code, sr.Syr_Ver_Code);
return(RedirectToAction(nameof(SystemRegistrationForm), new { cst_code = sr.Syr_Cst_Code,
sys_code = sr.Syr_Sys_Code,
ver_code = sr.Syr_Ver_Code,
mod_code,
cur_tab }));
}
public RedirectToActionResult Delete(SystemRegistration sr)
{
if (ModelState.IsValid)
{
sys_reg_repository.DeleteSystemRegistration(sr.Syr_Cst_Code,
sr.Syr_Sys_Code,
sr.Syr_Ver_Code);
}
return(RedirectToAction(nameof(ModuleController.Index)));
}
public IActionResult GetNext(SystemRegistration sr)
{
ModelState.Clear();
var model = sys_reg_repository.MoveNext(sr.Syr_Cst_Code, sr.Syr_Sys_Code, sr.Syr_Ver_Code);
if (model == null)
{
return(RedirectToAction(nameof(Index)));
}
return(RedirectToAction(nameof(SystemRegForm), model));
}
public ReportAction(SystemRegistration systemRegistration,
TimeSimulator timeSimulator,
Random random,
DiseaseRecordGenerator generator,
DiseaseSimulatorClient client,
string endpoint)
{
SystemRegistration = systemRegistration;
TimeSimulator = timeSimulator;
Random = random;
DiseaseGenerator = generator;
DiseaseSimulatorClient = client;
Endpoint = endpoint;
}
public void TestLogServerFromClient()
{
// Arrange
var endpoint = "tcp://127.0.0.1:55011";
var nsEndpoint = "tcp://127.0.0.1:55021";
var msgPushSocket = "This is a message from a PUSH zsocket.";
var msgLogger = "This is a test message from the LoggerClient.";
var clientName = "Test Client";
var systemRegistration = new SystemRegistration(clientName, endpoint)
{
Id = 1
};
var logList = new List <string>();
var mockLog = new Mock <ILogger>();
var loggerServer = new LoggerServer("Test Logger Server", endpoint, nsEndpoint, mockLog.Object);
mockLog.Setup(l => l.WriteLine(It.IsAny <string>())).Callback((string msg) => {
logList.Add(msg);
if (logList.Count > 1)
{
loggerServer.Stop();
}
});
var task = Task.Run(() => loggerServer.StartAsync(endpoint));
Thread.Sleep(300);
var pushContext = new ZContext();
var pushSocket = new ZSocket(pushContext, ZSocketType.PUSH);
pushSocket.Connect(endpoint);
var loggerClient = new LoggerClient(endpoint, clientName, nsEndpoint);
var vts = new VectorTimeStamp();
vts.Update(systemRegistration.Id, DateTime.Now);
// Act
loggerClient.WriteLine(msgLogger, vts);
Thread.Sleep(25);
pushSocket.Send(new ZFrame(msgPushSocket));
task.Wait();
// Assert
Assert.AreEqual(2, logList.Count);
Assert.AreEqual($"{clientName}:{vts}: {msgLogger}", logList[0]);
Assert.AreEqual(msgPushSocket, logList[1]);
}
public ViewResult SearchModule(SystemRegistration sr, string Mod_Code)
{
List <Module> modules = new List <Module>();
foreach (var mr in mod_reg_repository.ModuleRegistrations.Where(r => r.Mor_Cst_Code == sr.Syr_Cst_Code &&
r.Mor_Sys_Code == sr.Syr_Sys_Code &&
r.Mor_Ver_Code == sr.Syr_Ver_Code))
{
modules.Add(mod_repo.Modules.FirstOrDefault(r => r.Mod_Sys_Code == mr.Mor_Sys_Code &&
r.Mod_Code == mr.Mor_Mod_Code));
}
ViewBag.ControllerName = "SystemRegistration";
if (string.IsNullOrWhiteSpace(Mod_Code))
{
return(View("SearchModule", modules.Where(m => m.Mod_Sys_Code == sr.Syr_Sys_Code)));
}
return(View("SearchModule", modules.Where(m => m.Mod_Sys_Code == sr.Syr_Sys_Code &&
m.Mod_Code == Mod_Code)));
}
public IViewComponentResult Invoke(SystemRegistration sr)
{
if (sr == null)
{
return(View());
}
var module_regs = repository.ModuleRegistrations.Where(
r => r.Mor_Cst_Code == sr.Syr_Cst_Code &&
r.Mor_Sys_Code == sr.Syr_Sys_Code &&
r.Mor_Ver_Code == sr.Syr_Ver_Code);
List <Module> modules = new List <Module>();
foreach (var r in module_regs)
{
modules.Add(mod_repo.Modules.FirstOrDefault(m => m.Mod_Code == r.Mor_Mod_Code &&
m.Mod_Sys_Code == r.Mor_Sys_Code));
}
return(View(modules));
}
public IViewComponentResult Invoke(SystemRegistration sr)
{
if (sr == null)
{
return(View());
}
var enhancement_regs = repository.EnhancementRegistrations.Where(
r => r.Enr_Cst_Code == sr.Syr_Cst_Code &&
r.Enr_Sys_Code == sr.Syr_Sys_Code &&
r.Enr_Ver_Code == sr.Syr_Ver_Code);
List <Enhancement> enhancements = new List <Enhancement>();
foreach (var r in enhancement_regs)
{
enhancements.Add(enh_repo.Enhancements.FirstOrDefault(e => e.Enh_Code == r.Enr_Mod_Code &&
e.Enh_Sys_Code == r.Enr_Sys_Code));
}
return(View(enhancements));
}
public void DynamicNameServerTest()
{
// Arrange
var mockLogger = new Mock <ILogger>();
var mockRepo = new Mock <IRepository <SystemRegistration> >();
var server = new DynamicNameServer("DNS System", mockLogger.Object)
{
UseLocalHost = true,
Logger = mockLogger.Object,
Repo = mockRepo.Object
};
var systemRegistration = new SystemRegistration("S1");
// Act
server.RegisterSystem(systemRegistration);
// Assert
Assert.AreEqual(10, systemRegistration.Id);
Assert.AreEqual(new IPAddress(new byte[] { 192, 168, 0, 2 }), systemRegistration.IpAddress);
Assert.IsTrue(systemRegistration.Port >= 5000 && systemRegistration.Port <= 65000);
Assert.AreEqual(10, systemRegistration.Id);
mockRepo.Verify(r => r.Create(It.IsAny <SystemRegistration>()), Times.Once);
mockRepo.Verify(r => r.Create(It.IsAny <SystemRegistration>()), Times.Once);
}
public ViewResult SearchVersion(SystemRegistration sr)
{
ViewBag.ControllerName = "SystemRegistration";
return(View("SearchVersion", ver_repo.Search(sr.Syr_Sys_Code, sr.Syr_Ver_Code)));
}
public ViewResult SearchSystem(SystemRegistration sr)
{
ViewBag.ControllerName = "SystemRegistration";
ViewBag.Cst_Code = sr.Syr_Cst_Code;
return(View("Search", sys_repo.Search(sr.Syr_Sys_Code)));
}
public DynamicNameServer(string name, ILogger logger, IpAddress subnet = null)
{
Logger = logger;
SystemRegistration = new SystemRegistration(name);
ConfiguredSubnet = subnet;
}
public IActionResult SystemRegForm([FromBody] SystemRegistration sr) => RedirectToAction(nameof(SystemRegistrationForm), sr);
public IActionResult SelectModules(SystemRegistration sr)
{
module_selection_list = new ModuleSelectionList(mod_repo, sr, mod_reg_repository);
return(View(module_selection_list));
}
