public void Delete(string id)
{
var deviceKey = PartionKeyRowKeyPair.CreateFromIdentity(id);
var deviceRepository = new DeviceRepository(_tableEntityOperation);
var networkRepository = new NetworkRepository(_tableEntityOperation);
var deviceTableEntity = deviceRepository.Get(deviceKey);
if (deviceTableEntity == null)
{
throw new NotFoundException();
}
var parentNetworkKey = PartionKeyRowKeyPair.CreateFromIdentity(deviceTableEntity.NetworkId);
deviceRepository.Delete(deviceTableEntity);
TransientErrorHandling.Run(() =>
{
var parentNetwork = networkRepository.Get(parentNetworkKey);
for (var idx = 0; idx < parentNetwork.Devices.Count; idx++)
{
if (parentNetwork.Devices[idx].Id == id)
{
parentNetwork.Devices.RemoveAt(idx);
break;
}
}
networkRepository.Update(parentNetwork);
});
}
public string Create(Device device)
{
var deviceIdentity = Identity.Next();
var deviceKey = PartionKeyRowKeyPair.CreateFromIdentity(deviceIdentity);
var deviceRepository = new DeviceRepository(_tableEntityOperation);
var networkRepository = new NetworkRepository(_tableEntityOperation);
var deviceTableEntity = new DeviceTableEntity(deviceKey, device.Name, device.Network.Id, device.Service.Id,
device.Company.Id, device.DeviceKey, device.NumericId);
deviceRepository.Create(deviceTableEntity);
TransientErrorHandling.Run(() =>
{
var parentNetworkKey = PartionKeyRowKeyPair.CreateFromIdentity(device.Network.Id);
var parentNetwork = networkRepository.Get(parentNetworkKey);
parentNetwork.Devices.Add(new Small()
{
Id = deviceIdentity, Name = device.Name
});
networkRepository.Update(parentNetwork);
});
return(deviceIdentity);
}
public void Update(Network network)
{
var networkKey = PartionKeyRowKeyPair.CreateFromIdentity(network.Id);
var networkRepository = new NetworkRepository(_tableEntityOperation);
var networkTableEntity = networkRepository.Get(networkKey);
if (networkTableEntity == null)
{
throw new NotFoundException();
}
networkTableEntity.Name = network.Name;
networkTableEntity.TelemetryDataSinkSettings = network.TelemetryDataSinkSettings;
networkRepository.Update(networkTableEntity);
if (networkTableEntity.ParentNetworkId == null)
{
var serviceKey = PartionKeyRowKeyPair.CreateFromIdentity(networkTableEntity.ServiceId);
TransientErrorHandling.Run(() =>
{
var serviceRepository = new ServiceRepository(_tableEntityOperation);
var service = serviceRepository.Get(serviceKey);
for (var idx = 0; idx < service.Networks.Count; idx++)
{
if (service.Networks[idx].Id == network.Id)
{
service.Networks[idx].Name = network.Name;
break;
}
}
serviceRepository.Update(service);
});
}
else
{
var parentNetworkKey = PartionKeyRowKeyPair.CreateFromIdentity(networkTableEntity.ParentNetworkId);
TransientErrorHandling.Run(() =>
{
var parentNetwork = networkRepository.Get(parentNetworkKey);
for (var idx = 0; idx < parentNetwork.Networks.Count; idx++)
{
if (parentNetwork.Networks[idx].Id == network.Id)
{
parentNetwork.Networks[idx].Name = network.Name;
break;
}
}
networkRepository.Update(parentNetwork);
});
}
}
public void Delete(string id)
{
var networkKey = PartionKeyRowKeyPair.CreateFromIdentity(id);
var networkRepository = new NetworkRepository(_tableEntityOperation);
var networkTableEntity = networkRepository.Get(networkKey);
if (networkTableEntity == null)
{
throw new NotFoundException();
}
var serviceKey = PartionKeyRowKeyPair.CreateFromIdentity(networkTableEntity.ServiceId);
var parentNetworkKey = networkTableEntity.ParentNetworkId != null
? PartionKeyRowKeyPair.CreateFromIdentity(networkTableEntity.ParentNetworkId)
: null;
networkRepository.Delete(networkTableEntity);
if (parentNetworkKey == null)
{
TransientErrorHandling.Run(() =>
{
var serviceRepository = new ServiceRepository(_tableEntityOperation);
var service = serviceRepository.Get(serviceKey);
for (var idx = 0; idx < service.Networks.Count; idx++)
{
if (service.Networks[idx].Id == id)
{
service.Networks.RemoveAt(idx);
break;
}
}
serviceRepository.Update(service);
});
}
else
{
TransientErrorHandling.Run(() =>
{
var parentNetwork = networkRepository.Get(parentNetworkKey);
for (var idx = 0; idx < parentNetwork.Networks.Count; idx++)
{
if (parentNetwork.Networks[idx].Id == id)
{
parentNetwork.Networks.RemoveAt(idx);
break;
}
}
networkRepository.Update(parentNetwork);
});
}
}
public void DeviceCommandTest()
{
var network = new Network("N1");
NetworkRepository.Save(network);
var deviceClass = new DeviceClass("D1", "V1");
DeviceClassRepository.Save(deviceClass);
var device = new Device(Guid.NewGuid(), "key", "Test", network, deviceClass);
DeviceRepository.Save(device);
var command = new DeviceCommand("Test", device);
DeviceCommandRepository.Save(command);
// test GetByDevice
var commands = DeviceCommandRepository.GetByDevice(device.ID, null, null);
Assert.Greater(commands.Count, 0);
// test Get(id)
var command1 = DeviceCommandRepository.Get(command.ID);
Assert.IsNotNull(command1);
Assert.AreEqual("Test", command1.Command);
Assert.AreEqual(device.ID, command1.DeviceID);
// test Save
command.Command = "Test2";
command.Parameters = "{}";
command.Status = "OK";
command.Result = "\"Success\"";
command.UserID = 1;
DeviceCommandRepository.Save(command);
var command2 = DeviceCommandRepository.Get(command.ID);
Assert.AreEqual("Test2", command2.Command);
Assert.AreEqual("{}", command2.Parameters);
Assert.AreEqual("OK", command2.Status);
Assert.AreEqual("\"Success\"", command2.Result);
Assert.AreEqual(1, command2.UserID);
// test Delete
DeviceCommandRepository.Delete(command.ID);
var command3 = DeviceCommandRepository.Get(command.ID);
Assert.IsNull(command3);
}
public void DeviceEquipmentTest()
{
var network = new Network("N1");
NetworkRepository.Save(network);
var deviceClass = new DeviceClass("D1", "V1");
DeviceClassRepository.Save(deviceClass);
var device = new Device(Guid.NewGuid(), "key", "Test", network, deviceClass);
DeviceRepository.Save(device);
var equipment = new DeviceEquipment("Test", DateTime.UtcNow, device);
DeviceEquipmentRepository.Save(equipment);
// test GetByDevice
var equipments = DeviceEquipmentRepository.GetByDevice(device.ID);
Assert.Greater(equipments.Count, 0);
// test GetByDeviceAndCode
var equipment0 = DeviceEquipmentRepository.GetByDeviceAndCode(device.ID, "Test");
Assert.IsNotNull(equipment0);
// test Get(id)
var equipment1 = DeviceEquipmentRepository.Get(equipment.ID);
Assert.IsNotNull(equipment1);
Assert.AreEqual("Test", equipment1.Code);
Assert.AreEqual(device.ID, equipment1.DeviceID);
// test Save
equipment.Code = "Test2";
equipment.Parameters = "{}";
DeviceEquipmentRepository.Save(equipment);
var equipment2 = DeviceEquipmentRepository.Get(equipment.ID);
Assert.AreEqual("Test2", equipment2.Code);
Assert.AreEqual("{}", equipment2.Parameters);
// test Delete
DeviceEquipmentRepository.Delete(equipment.ID);
var equipment3 = DeviceEquipmentRepository.Get(equipment.ID);
Assert.IsNull(equipment3);
}
public string Create(Network network)
{
var networkIdentity = Identity.Next();
var networkKey = PartionKeyRowKeyPair.CreateFromIdentity(networkIdentity);
var networkRepository = new NetworkRepository(_tableEntityOperation);
var networkTableEntity = new NetworkTableEntity(
networkKey,
network.Name,
network.ParentNetwork != null ? network.ParentNetwork.Id : null,
network.Service.Id,
network.Company.Id, network.NetworkKey);
networkRepository.Create(networkTableEntity);
if (network.ParentNetwork == null)
{
var serviceKey = PartionKeyRowKeyPair.CreateFromIdentity(network.Service.Id);
TransientErrorHandling.Run(() =>
{
var serviceRepository = new ServiceRepository(_tableEntityOperation);
var service = serviceRepository.Get(serviceKey);
service.Networks.Add(new Small()
{
Id = networkIdentity, Name = network.Name
});
serviceRepository.Update(service);
});
}
else
{
TransientErrorHandling.Run(() =>
{
var parentNetworkKey = PartionKeyRowKeyPair.CreateFromIdentity(network.ParentNetwork.Id);
var parentNetwork = networkRepository.Get(parentNetworkKey);
parentNetwork.Networks.Add(new Small()
{
Id = networkIdentity, Name = network.Name
});
networkRepository.Update(parentNetwork);
});
}
return(networkIdentity);
}
// ReSharper disable once InconsistentNaming
public async Task GetNetworkByNameAsync_should_return_null_if_no_network_found()
{
using (var context = CreateContext())
{
await SeedGenresAsync(context);
var repo = new NetworkRepository(context);
const string Name = "bbc1";
var network = await repo.GetNetworkByNameAsync(Name);
Assert.Null(network);
}
}
// ReSharper disable once InconsistentNaming
public async Task GetNetworkByNameAsync_should_return_network_by_name()
{
using (var context = CreateContext())
{
await SeedGenresAsync(context);
var repo = new NetworkRepository(context);
const string Name = "bbc";
var network = await repo.GetNetworkByNameAsync(Name);
Assert.Equal(Name, network.Name);
}
}
public IList <Small> ListDevices(string networkId)
{
var networkKey = PartionKeyRowKeyPair.CreateFromIdentity(networkId);
var networkRepository = new NetworkRepository(_tableEntityOperation);
var network = networkRepository.Get(networkKey);
if (network == null)
{
throw new NotFoundException();
}
return(network.Devices);
}
protected override IProNet LoadProNet(string filename)
{
// load your implementation here
var fileService = new FileService();
var networkValidator = new NetworkValidator();
var networkService = new NetworkRepository(fileService, filename, networkValidator);
var rankService = new RankService(networkService);
var skillsService = new SkillsService(networkService);
var separationService = new SeparationService(networkService);
var recommendationService = new RecommendationService(networkService);
var teamStrengthService = new TeamStrengthService(separationService, skillsService, rankService);
var permutationService = new PermutationService();
var strongestTeamService = new StrongestTeamService(networkService, teamStrengthService, permutationService);
return(new ProNet(rankService, skillsService, separationService, recommendationService, teamStrengthService, strongestTeamService));
}
public void DeviceNotificationTest()
{
var network = new Network("N1");
NetworkRepository.Save(network);
var deviceClass = new DeviceClass("D1", "V1");
DeviceClassRepository.Save(deviceClass);
var device = new Device(Guid.NewGuid(), "key", "Test", network, deviceClass);
DeviceRepository.Save(device);
var notification = new DeviceNotification("Test", device);
DeviceNotificationRepository.Save(notification);
// test GetByDevice
var notifications = DeviceNotificationRepository.GetByDevice(device.ID, null, null);
Assert.Greater(notifications.Count, 0);
// test Get(id)
var notification1 = DeviceNotificationRepository.Get(notification.ID);
Assert.IsNotNull(notification1);
Assert.AreEqual("Test", notification1.Notification);
Assert.AreEqual(device.ID, notification1.DeviceID);
// test Save
notification.Notification = "Test2";
notification.Parameters = "{}";
DeviceNotificationRepository.Save(notification);
var notification2 = DeviceNotificationRepository.Get(notification.ID);
Assert.AreEqual("Test2", notification2.Notification);
Assert.AreEqual("{}", notification2.Parameters);
// test Delete
DeviceNotificationRepository.Delete(notification.ID);
var notification3 = DeviceNotificationRepository.Get(notification.ID);
Assert.IsNull(notification3);
}
public void UserNetworkTest()
{
var user = new User("Test", "TestPass", (int)UserRole.Administrator, (int)UserStatus.Active);
UserRepository.Save(user);
var network = new Network("Test");
NetworkRepository.Save(network);
var userNetwork = new UserNetwork(user, network);
UserNetworkRepository.Save(userNetwork);
// test GetByUser
var userNetworks1 = UserNetworkRepository.GetByUser(user.ID);
Assert.Greater(userNetworks1.Count, 0);
// test GetByNetwork
var userNetworks2 = UserNetworkRepository.GetByNetwork(network.ID);
Assert.Greater(userNetworks2.Count, 0);
// test Get(id)
var userNetwork1 = UserNetworkRepository.Get(userNetwork.ID);
Assert.IsNotNull(userNetwork1);
Assert.AreEqual(user.ID, userNetwork1.UserID);
Assert.AreEqual(network.ID, userNetwork1.NetworkID);
Assert.IsNotNull(userNetwork1.User);
Assert.IsNotNull(userNetwork1.Network);
// test Get(userId, networkId)
var userNetwork2 = UserNetworkRepository.Get(user.ID, network.ID);
Assert.IsNotNull(userNetwork2);
// test Delete
UserNetworkRepository.Delete(userNetwork.ID);
var userNetwork3 = UserNetworkRepository.Get(userNetwork.ID);
Assert.IsNull(userNetwork3);
}
public DataManager()
{
//init db
bool needSeeding = false;
var dbcontext = new EntityFrameworkContext();
needSeeding = dbcontext.Database.CreateIfNotExists();
//init repositories
Kunden = new KundenRepository(dbcontext);
Networks = new NetworkRepository(dbcontext);
Telefontarife = new TelefontarifeRepository(dbcontext);
Datentarife = new DatentarifRepository(dbcontext);
//seed if necessary
if (needSeeding)
{
this.Seed();
Console.WriteLine("database seeded");
}
}
public void NetworkTest()
{
var network = new Network("Test")
{
Key = "Key"
};
NetworkRepository.Save(network);
// test GetAll
var networks = NetworkRepository.GetAll();
Assert.Greater(networks.Count, 0);
// test Get(id)
var network1 = NetworkRepository.Get(network.ID);
Assert.IsNotNull(network1);
Assert.AreEqual("Test", network1.Name);
// test Get(name)
var network2 = NetworkRepository.Get("Test");
Assert.IsNotNull(network2);
// test Save
network.Name = "Test2";
network.Description = "Desc";
NetworkRepository.Save(network);
var network4 = NetworkRepository.Get(network.ID);
Assert.AreEqual("Test2", network4.Name);
Assert.AreEqual("Desc", network4.Description);
// test Delete
NetworkRepository.Delete(network.ID);
var network5 = NetworkRepository.Get(network.ID);
Assert.IsNull(network5);
}
public Network Get(string id)
{
var networkKey = PartionKeyRowKeyPair.CreateFromIdentity(id);
var networkRepository = new NetworkRepository(_tableEntityOperation);
var networkTableEntity = networkRepository.Get(networkKey);
if (networkTableEntity == null)
{
throw new NotFoundException();
}
return(new Network
{
Id = id,
Name = networkTableEntity.Name,
ParentNetwork =
networkTableEntity.ParentNetworkId != null
? new Network()
{
Id = networkTableEntity.ParentNetworkId
}
: null,
ParentNetworkId = networkTableEntity.ParentNetworkId,
Service = new Service()
{
Id = networkTableEntity.ServiceId
},
ServiceId = networkTableEntity.ServiceId,
Company = new Company()
{
Id = networkTableEntity.CompanyId
},
TelemetryDataSinkSettings = networkTableEntity.TelemetryDataSinkSettings,
NetworkKey = networkTableEntity.NetworkKey
});
}
public void Update(Device device)
{
var deviceKey = PartionKeyRowKeyPair.CreateFromIdentity(device.Id);
var deviceRepository = new DeviceRepository(_tableEntityOperation);
var networkRepository = new NetworkRepository(_tableEntityOperation);
var deviceTableEntity = deviceRepository.Get(deviceKey);
if (deviceTableEntity == null)
{
throw new NotFoundException();
}
deviceTableEntity.Name = device.Name;
deviceTableEntity.DeviceKey = device.DeviceKey;
deviceTableEntity.NumericId = device.NumericId;
deviceRepository.Update(deviceTableEntity);
TransientErrorHandling.Run(() =>
{
var parentNetworkKey = PartionKeyRowKeyPair.CreateFromIdentity(deviceTableEntity.NetworkId);
var parentNetwork = networkRepository.Get(parentNetworkKey);
for (var idx = 0; idx < parentNetwork.Devices.Count; idx++)
{
if (parentNetwork.Devices[idx].Id == device.Id)
{
parentNetwork.Devices[idx].Name = device.Name;
break;
}
}
networkRepository.Update(parentNetwork);
});
}
public UnitOfWork(string connection, IContextService instance)
{
_logger = LoggerFactory.Create(opt =>
{
opt.AddFilter("Microsoft", LogLevel.Warning)
.AddFilter("Microsoft.EntityFrameworkCore", LogLevel.Information)
.AddFilter("System", LogLevel.Warning)
.AddConsole();
});
switch (instance.InstanceType)
{
case InstanceContext.DeployedOrLocal:
{
#if !RELEASE
var builder = new DbContextOptionsBuilder <AuroraEntities>()
.UseSqlServer(connection);
//.UseLoggerFactory(_logger)
//.EnableSensitiveDataLogging();
#elif RELEASE
var builder = new DbContextOptionsBuilder <AuroraEntities>()
.UseSqlServer(connection);
#endif
_context = new AuroraEntities(builder.Options);
}
break;
case InstanceContext.End2EndTest:
case InstanceContext.IntegrationTest:
case InstanceContext.UnitTest:
{
#if !RELEASE
var builder = new DbContextOptionsBuilder <AuroraEntities>()
.UseInMemoryDatabase(":InMemory:")
.UseLoggerFactory(_logger)
.EnableSensitiveDataLogging();
#elif RELEASE
var builder = new DbContextOptionsBuilder <AuroraEntities>()
.UseInMemoryDatabase(":InMemory:");
#endif
_context = new AuroraEntities(builder.Options);
}
break;
default:
throw new NotImplementedException();
}
_context.ChangeTracker.LazyLoadingEnabled = false;
_context.ChangeTracker.CascadeDeleteTiming = CascadeTiming.Immediate;
InstanceType = instance.InstanceType;
Credentials = new CredentialRepository(_context);
Networks = new NetworkRepository(_context);
PrivateKeys = new PrivateKeyRepository(_context);
PublicKeys = new PublicKeyRepository(_context);
Settings = new SettingRepository(_context);
UserFiles = new UserFileRepository(_context);
UserFolders = new UserFolderRepository(_context);
UserMounts = new UserMountRepository(_context);
Users = new UserRepository(_context);
}
public NetworkController(NetworkRepository repo)
{
_repo = repo;
}
public void DeviceTest()
{
var network = new Network("N1");
NetworkRepository.Save(network);
var deviceClass = new DeviceClass("D1", "V1");
DeviceClassRepository.Save(deviceClass);
var device = new Device(Guid.NewGuid(), "key", "Test", network, deviceClass);
DeviceRepository.Save(device);
// test GetByNetwork
var devices = DeviceRepository.GetByNetwork(network.ID);
Assert.Greater(devices.Count, 0);
// test Get(id)
var device1 = DeviceRepository.Get(device.ID);
Assert.IsNotNull(device1);
Assert.AreEqual(device.GUID, device1.GUID);
Assert.AreEqual("Test", device1.Name);
Assert.AreEqual(network.ID, device1.NetworkID);
Assert.AreEqual(deviceClass.ID, device1.DeviceClassID);
Assert.IsNotNull(device1.Network);
Assert.IsNotNull(device1.DeviceClass);
// test Get(guid)
var device2 = DeviceRepository.Get(device.GUID);
Assert.IsNotNull(device2);
Assert.AreEqual(device.GUID, device2.GUID);
Assert.AreEqual("Test", device2.Name);
Assert.AreEqual(network.ID, device2.NetworkID);
Assert.AreEqual(deviceClass.ID, device2.DeviceClassID);
Assert.IsNotNull(device2.Network);
Assert.IsNotNull(device2.DeviceClass);
// test Save
device.Name = "Test2";
device.Status = "Status";
device.Data = "{}";
device.Network = null;
device.NetworkID = null;
DeviceRepository.Save(device);
var device3 = DeviceRepository.Get(device.ID);
Assert.AreEqual("Test2", device3.Name);
Assert.AreEqual("Status", device3.Status);
Assert.AreEqual("{}", device3.Data);
Assert.IsNull(device3.Network);
Assert.IsNull(device3.NetworkID);
// test update relationship
var deviceClass2 = new DeviceClass("D2", "V2");
DeviceClassRepository.Save(deviceClass2);
device.DeviceClass = deviceClass2;
DeviceRepository.Save(device);
var device4 = DeviceRepository.Get(device.ID);
Assert.AreEqual(deviceClass2.ID, device4.DeviceClassID);
Assert.IsNotNull(device4.DeviceClass);
// test Delete
DeviceRepository.Delete(device.ID);
var device5 = DeviceRepository.Get(device.ID);
Assert.IsNull(device5);
}
