public SettingTableEntity(PartionKeyRowKeyPair partitionKeyRowKeyPair, string value)
{
PartitionKey = partitionKeyRowKeyPair.PartitionKey;
RowKey = partitionKeyRowKeyPair.RowKey;
Value = value;
}
public Device Get(string id)
{
var deviceKey = PartionKeyRowKeyPair.CreateFromIdentity(id);
var deviceRepository = new DeviceRepository(_tableEntityOperation);
var deviceTableEntity = deviceRepository.Get(deviceKey);
if (deviceTableEntity == null)
{
throw new NotFoundException();
}
return(new Device
{
Id = id,
Name = deviceTableEntity.Name,
Network = new Network()
{
Id = deviceTableEntity.NetworkId
},
Service = new Service()
{
Id = deviceTableEntity.ServiceId
},
Company = new Company()
{
Id = deviceTableEntity.CompanyId
},
DeviceKey = deviceTableEntity.DeviceKey,
NumericId = deviceTableEntity.NumericId
});
}
public TE Get <TE>(string tableName, PartionKeyRowKeyPair paritionKeyRowKeyPair)
where TE : TableEntity
{
var table = GetTableReference(tableName);
try
{
var result =
table.Execute(TableOperation.Retrieve <TE>(paritionKeyRowKeyPair.PartitionKey,
paritionKeyRowKeyPair.RowKey));
if (result.HttpStatusCode == (int)HttpStatusCode.OK && result.Result != null)
{
return((TE)result.Result);
}
if (result.HttpStatusCode == (int)HttpStatusCode.NotFound ||
(result.HttpStatusCode == (int)HttpStatusCode.OK && result.Result == null))
{
return(default(TE));
}
throw new StorageAccessException((HttpStatusCode)result.HttpStatusCode);
}
catch (StorageException sex)
{
throw new StorageAccessException((HttpStatusCode)sex.RequestInformation.HttpStatusCode);
}
}
public string Create(Service service)
{
var serviceIdentity = Identity.Next();
var serviceKey = PartionKeyRowKeyPair.CreateFromIdentity(serviceIdentity);
var companyKey = PartionKeyRowKeyPair.CreateFromIdentity(service.Company.Id);
var serviceRepository = new ServiceRepository(_tableEntityOperation);
var serviceTableEntity = new ServiceTableEntity(serviceKey, service.Name, service.Company.Id, service.ApiKey);
serviceRepository.Create(serviceTableEntity);
TransientErrorHandling.Run(() =>
{
var companyRepository = new CompanyRepository(_tableEntityOperation);
var company = companyRepository.Get(companyKey);
company.Services.Add(new Small()
{
Id = serviceIdentity, Name = service.Name
});
companyRepository.Update(company);
});
return(serviceIdentity);
}
public Service Get(string id)
{
var serviceKey = PartionKeyRowKeyPair.CreateFromIdentity(id);
var serviceRepository = new ServiceRepository(_tableEntityOperation);
var serviceTableEntity = serviceRepository.Get(serviceKey);
if (serviceTableEntity == null)
{
throw new NotFoundException();
}
return(new Service
{
Id = id,
Name = serviceTableEntity.Name,
Company = new Company()
{
Id = serviceTableEntity.CompanyId
},
TelemetryDataSinkSettings = serviceTableEntity.TelemetryDataSinkSettings,
ApiKey = serviceTableEntity.ApiKey
});
}
public string Create(Company company, string userId)
{
var companyIdentity = Identity.Next();
var companyKey = PartionKeyRowKeyPair.CreateFromIdentity(companyIdentity);
var userKey = PartionKeyRowKeyPair.CreateFromIdentity(userId);
var userRepository = new UserRepository(_tableEntityOperation);
var userTableEntity = userRepository.Get(userKey);
var companyRepository = new CompanyRepository(_tableEntityOperation);
var companyTableEntity = new CompanyTableEntity(companyKey, company.Name,
new List <SmallUser>
{
new SmallUser {
Id = userId, Name = userTableEntity.Name, Email = userTableEntity.Email
}
});
companyRepository.Create(companyTableEntity);
TransientErrorHandling.Run(() =>
{
userTableEntity = userRepository.Get(userKey);
userTableEntity.Companies.Add(new Small {
Id = companyIdentity, Name = company.Name
});
userRepository.Update(userTableEntity);
});
return(companyIdentity);
}
public void Delete(string id)
{
var serviceKey = PartionKeyRowKeyPair.CreateFromIdentity(id);
var serviceRepository = new ServiceRepository(_tableEntityOperation);
var serviceTableEntity = serviceRepository.Get(serviceKey);
if (serviceTableEntity == null)
{
throw new NotFoundException();
}
var companyKey = PartionKeyRowKeyPair.CreateFromIdentity(serviceTableEntity.CompanyId);
serviceRepository.Delete(serviceTableEntity);
TransientErrorHandling.Run(() =>
{
var companyRepository = new CompanyRepository(_tableEntityOperation);
var company = companyRepository.Get(companyKey);
for (var idx = 0; idx < company.Services.Count; idx++)
{
if (company.Services[idx].Id == id)
{
company.Services.RemoveAt(idx);
break;
}
}
companyRepository.Update(company);
});
}
public void Delete(string id)
{
var companyKey = PartionKeyRowKeyPair.CreateFromIdentity(id);
var companyRepository = new CompanyRepository(_tableEntityOperation);
var companyTableEntity = companyRepository.Get(companyKey);
if (companyTableEntity == null)
{
throw new NotFoundException();
}
var userIds = companyTableEntity.Users.Select(u => u.Id).ToList();
companyRepository.Delete(companyTableEntity);
TransientErrorHandling.Run(() =>
{
var userRepository = new UserRepository(_tableEntityOperation);
foreach (var userId in userIds)
{
var userKey = PartionKeyRowKeyPair.CreateFromIdentity(userId);
var user = userRepository.Get(userKey);
user.Companies.Remove(user.Companies.Single(c => c.Id == id));
userRepository.Update(user);
}
});
}
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 TimeSeriesTableEntity(PartionKeyRowKeyPair partitionKeyRowKeyPair, string payload)
{
PartitionKey = partitionKeyRowKeyPair.PartitionKey;
RowKey = partitionKeyRowKeyPair.RowKey;
Payload = payload;
}
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 IEnumerable <Small> ListDevices(IEnumerable <string> ids)
{
var list = new List <Small>();
var allIds = ids.ToList();
var deviceRepository = new DeviceRepository(_tableEntityOperation);
var networkRepository = new GenericRepository <NetworkDevicesTableEntity>(_tableEntityOperation, "Network");
// suppose that the different ids are from a small number of networks
while (allIds.Any())
{
var deviceKey = PartionKeyRowKeyPair.CreateFromIdentity(allIds.First());
var deviceTableEntity = deviceRepository.Get(deviceKey);
if (deviceTableEntity == null)
{
allIds.RemoveAt(0);
continue;
}
var networkKey = PartionKeyRowKeyPair.CreateFromIdentity(deviceTableEntity.NetworkId);
var network = networkRepository.Get(networkKey);
list.AddRange(network.Devices.Where(d => allIds.Contains(d.Id)));
var deviceIds = network.Devices.Select(d => d.Id).ToList();
allIds.RemoveAll(deviceIds.Contains);
}
return(list);
}
public CurrentDataTableEntity(PartionKeyRowKeyPair partitionKeyRowKeyPair, DateTime time, string payload)
{
PartitionKey = partitionKeyRowKeyPair.PartitionKey;
RowKey = partitionKeyRowKeyPair.RowKey;
Time = time;
Payload = payload;
}
public IList <Small> ListCompanies(string userIdentity)
{
var userKey = PartionKeyRowKeyPair.CreateFromIdentity(userIdentity);
var userRepository = new UserRepository(_tableEntityOperation);
return(userRepository.Get(userKey).Companies);
}
public void Create(Setting setting)
{
var settingKey = new PartionKeyRowKeyPair(setting.Category, setting.Config);
var settingRepository = new SettingRepository(_tableEntityOperation);
var settingTableEntity = new SettingTableEntity(settingKey, setting.Value);
settingRepository.Create(settingTableEntity);
}
public CompanyTableEntity(PartionKeyRowKeyPair partitionKeyRowKeyPair, string name, IList <SmallUser> users)
{
PartitionKey = partitionKeyRowKeyPair.PartitionKey;
RowKey = partitionKeyRowKeyPair.RowKey;
Name = name;
Users = users;
TelemetryDataSinkSettings = new TelemetryDataSinkSettings();
}
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 IEnumerable <Small> ListDevices(string id)
{
var networkKey = PartionKeyRowKeyPair.CreateFromIdentity(id);
var networkRepository = new GenericRepository <NetworkDevicesTableEntity>(_tableEntityOperation, "Network");
var network = networkRepository.Get(networkKey);
return(network.Devices);
}
public override void Record(TelemetryData message)
{
var currentDataRepository = new GenericRepository <CurrentDataTableEntity>(TableEntityOperation, TableName);
var partitionKeyRowKeyPair = PartionKeyRowKeyPair.CreateFromIdentity(message.DeviceId);
var currentDataTableEntity = new CurrentDataTableEntity(partitionKeyRowKeyPair, message.Time, message.Payload);
currentDataRepository.Upsert(currentDataTableEntity);
}
public ServiceTableEntity(PartionKeyRowKeyPair partitionKeyRowKeyPair, string name, string companyId, string apiKey)
{
PartitionKey = partitionKeyRowKeyPair.PartitionKey;
RowKey = partitionKeyRowKeyPair.RowKey;
Name = name;
CompanyId = companyId;
ApiKey = apiKey;
TelemetryDataSinkSettings = new TelemetryDataSinkSettings();
}
public string Get(PartionKeyRowKeyPair partitionKeyRowKeyPair)
{
var partition = _entities.GetOrAdd(partitionKeyRowKeyPair.PartitionKey, new ConcurrentDictionary <string, string>());
string currentValue;
partition.TryGetValue(partitionKeyRowKeyPair.RowKey, out currentValue);
return(currentValue);
}
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 UserTableEntity(PartionKeyRowKeyPair partitionKeyRowKeyPair, string name, string email, IList <Small> companies, bool activated, string activationCode)
{
PartitionKey = partitionKeyRowKeyPair.PartitionKey;
RowKey = partitionKeyRowKeyPair.RowKey;
Name = name;
Companies = companies;
Email = email;
Activated = activated;
ActivationCode = activationCode;
}
public TE Get <TE>(string tableName, PartionKeyRowKeyPair partionKeyRowKeyPair) where TE : TableEntity
{
var entity = InMemoryDatabase.Instance.Get(tableName).Get(partionKeyRowKeyPair);
if (entity == null)
{
return(null);
}
return(Serializers.FromJsonString <TE>(entity));
}
public NetworkTableEntity(PartionKeyRowKeyPair partitionKeyRowKeyPair, string name, string parentNetworkId, string serviceId, string companyId, string networkKey)
{
PartitionKey = partitionKeyRowKeyPair.PartitionKey;
RowKey = partitionKeyRowKeyPair.RowKey;
Name = name;
ParentNetworkId = parentNetworkId;
ServiceId = serviceId;
CompanyId = companyId;
NetworkKey = networkKey;
TelemetryDataSinkSettings = new TelemetryDataSinkSettings();
}
public DeviceTableEntity(PartionKeyRowKeyPair partitionKeyRowKeyPair, string name, string networkId, string serviceId, string companyId, string deviceKey, long numericId)
{
PartitionKey = partitionKeyRowKeyPair.PartitionKey;
RowKey = partitionKeyRowKeyPair.RowKey;
Name = name;
NetworkId = networkId;
ServiceId = serviceId;
CompanyId = companyId;
DeviceKey = deviceKey;
NumericId = numericId;
}
public override void Record(TelemetryData message)
{
var timeSeriesRepository = new GenericRepository <TimeSeriesTableEntity>(TableEntityOperation, TableName);
var partitionKey = message.Time.ToString("yyyy-MM-dd") + "-" + message.DeviceId;
var rowKey = message.Time.Ticks.ToString(CultureInfo.InvariantCulture);
var partitionKeyRowKeyPair = new PartionKeyRowKeyPair(partitionKey, rowKey);
var timeSeriesTableEntity = new TimeSeriesTableEntity(partitionKeyRowKeyPair, message.Payload);
timeSeriesRepository.Create(timeSeriesTableEntity);
}
public void Delete(SettingId id)
{
var settingKey = new PartionKeyRowKeyPair(id.Category, id.Config);
var settingRepository = new SettingRepository(_tableEntityOperation);
var settingTableEntity = settingRepository.Get(settingKey);
if (settingTableEntity == null)
{
throw new NotFoundException();
}
settingRepository.Delete(settingTableEntity);
}
private static void CreateSettingIfNotExist(GenericRepository <SettingTableEntity> settingRepository,
SettingId settingId, string configurationSlot, string defaultValue)
{
var partitionKeyRowKeyPair = new PartionKeyRowKeyPair(settingId.Category, settingId.Config);
if (settingRepository.Get(partitionKeyRowKeyPair) == null)
{
var value = SettingReolver.Instance.Resolve(configurationSlot, defaultValue);
var settingTableEntity = new SettingTableEntity(settingId, value);
settingRepository.Create(settingTableEntity);
Console.WriteLine("Added {0}", settingId);
}
}
public void Update(User user)
{
var userKey = PartionKeyRowKeyPair.CreateFromIdentity(user.Id);
var userRepository = new UserRepository(_tableEntityOperation);
var userEntity = userRepository.Get(userKey);
userEntity.Name = user.Name;
userEntity.Activated = user.Activated;
userEntity.ActivationCode = user.ActivationCode;
userRepository.Update(userEntity);
}
