public async Task <IActionResult> Add(Guid spaceId)
{
CacheHelper.SetPreviousPage(_cache, Request.Headers["Referer"].ToString());
if (spaceId != Guid.Empty)
{
CacheHelper.SetObjectId(_cache, spaceId);
Space space = await DigitalTwinsHelper.GetSpaceAsync((Guid)spaceId, _cache, Loggers.SilentLogger);
var pksForSpace = (await DigitalTwinsHelper.GetPropertyKeysForSpace((Guid)spaceId, _cache, Loggers.SilentLogger)).ToList <PropertyKey>();
// we filter to remove all the properties already known in the Space
IEnumerable <PropertyKey> pks =
from pk in pksForSpace
where !space.Properties.Any(prop => prop.Name.Equals(pk.Name))
select pk;
return(View(pks));
}
else
{
//TODO replace with default view (List)
return(RedirectToAction(nameof(PropertyKeyController.Create)));
}
}
public async Task <IActionResult> Provision(ProvisionViewModel model)
{
Reset();
try
{
if (model.YamlScript == null)
{
throw new Exception("You must enter a valid YAML Script!");
}
IEnumerable <SpaceDescription> spaceCreateDescriptions;
spaceCreateDescriptions = new Deserializer().Deserialize <IEnumerable <SpaceDescription> >(model.YamlScript);
model.CreatedSpaces = await DigitalTwinsHelper.CreateSpaces(_cache, Loggers.SilentLogger, spaceCreateDescriptions, model.UDFFiles, model.RootParent.Id);
model.Messages = CacheHelper.GetInfoMessagesFromCache(_cache);
return(View(model));
}
catch (Exception ex)
{
FeedbackHelper.Channel.SendMessageAsync($"Error - {ex.Message}", MessageType.Info).Wait();
return(RedirectToAction(nameof(Index)));
}
}
private async Task LoadAsync(UserDefinedFunction udf)
{
SpaceList = await DigitalTwinsHelper.GetSpacesAsync(_cache, Loggers.SilentLogger);
if (udf != null)
{
UDF = udf;
Content = await DigitalTwinsHelper.GetUserDefinedFunctionContent(UDF.Id, _cache, Loggers.SilentLogger);
//We get the matcher list to add the related conditions
List <Matcher> matchersWithConditions = new List <Matcher>();
var matchers = await DigitalTwinsHelper.GetMatchersBySpaceId(UDF.SpaceId, _cache, Loggers.SilentLogger, false);
foreach (Matcher matcher in UDF.Matchers)
{
matchersWithConditions.Add(matchers.First(t => t.Id == matcher.Id));
}
UDF.Matchers = new ObservableCollection <Matcher>(matchersWithConditions);
}
else
{
UDF = new UserDefinedFunction();
}
}
public async Task <ActionResult> Add(List <Matcher> model, string updateButton)
{
if (updateButton.Equals("Cancel"))
{
return(Redirect(CacheHelper.GetPreviousPage(_cache)));
}
try
{
UserDefinedFunction udf = await DigitalTwinsHelper.GetUserDefinedFunction(CacheHelper.GetObjectId(_cache), _cache, Loggers.SilentLogger, true);
if (udf.Matchers == null)
{
udf.Matchers = new System.Collections.ObjectModel.ObservableCollection <Matcher>();
}
foreach (Matcher matcher in model)
{
if (matcher.Add)
{
udf.Matchers.Add(matcher);
}
}
await DigitalTwinsHelper.UpdateUserDefinedFunctionAsync(_cache, Loggers.SilentLogger, udf);
return(Redirect(CacheHelper.GetPreviousPage(_cache)));
}
catch (Exception ex)
{
await FeedbackHelper.Channel.SendMessageAsync(ex.Message, MessageType.Info);
return(View());
}
}
public async Task <ActionResult> Edit(MatcherViewModel model, string updateButton)
{
string previousPage = CacheHelper.GetPreviousPage(_cache);
if (updateButton.Equals("Cancel"))
{
return(Redirect(previousPage));
}
// we load the matcher in cache to restore the conditions previously defined
var matcher = await DigitalTwinsHelper.GetMatcherAsync(model.SelectedMatcher.Id, _cache, Loggers.SilentLogger, false);
matcher.Name = model.SelectedMatcher.Name;
// we update the matcher
await DigitalTwinsHelper.UpdateMatcherAsync(matcher, _cache, Loggers.SilentLogger);
// we associate the matcher with the UDF
//var udf = await DigitalTwinsHelper.GetUserDefinedFunction(model.UdfId, _cache, Loggers.SilentLogger, false);
//udf.Matchers.Add(matcher);
//await DigitalTwinsHelper.UpdateUserDefinedFunctionAsync(_cache, Loggers.SilentLogger, udf);
//we remove the matcher from the cache
CacheHelper.AddInCache(_cache, null, Guid.Empty, Context.Matcher);
return(RedirectToAction("Edit", "UDF", new { id = model.UdfId }));
}
public async Task <ActionResult> EditCondition(MatcherViewModel model, string updateButton)
{
string previousPage = CacheHelper.GetPreviousPage(_cache);
if (updateButton.Equals("Cancel"))
{
return(Redirect(previousPage));
}
var matcher = await DigitalTwinsHelper.GetMatcherAsync(model.SelectedMatcher.Id, _cache, Loggers.SilentLogger, false);
if (matcher != null)
{
var index = matcher.Conditions.FindIndex(m => m.Id == model.SelectedMatcherCondition.Id);
if (updateButton.Equals("Update"))
{
matcher.Conditions[index] = model.SelectedMatcherCondition;
}
if (updateButton.Equals("Delete"))
{
matcher.Conditions.RemoveAt(index);
}
CacheHelper.AddInCache(_cache, matcher, matcher.Id, Context.Matcher);
}
return(Redirect(previousPage));
}
public async Task <IActionResult> Add(Guid spaceId, Guid udfId)
{
CacheHelper.SetPreviousPage(_cache, Request.Headers["Referer"].ToString());
if (udfId != Guid.Empty)
{
CacheHelper.SetObjectId(_cache, udfId);
Space space = await DigitalTwinsHelper.GetSpaceAsync((Guid)spaceId, _cache, Loggers.SilentLogger);
var matchers = (await DigitalTwinsHelper.GetMatchersBySpaceId((Guid)spaceId, _cache, Loggers.SilentLogger, false)).ToList <Matcher>();
var udf = await DigitalTwinsHelper.GetUserDefinedFunction(udfId, _cache, Loggers.SilentLogger, false);
// we filter to remove all the matchers already associated with the UDF
IEnumerable <Matcher> mtcs =
from mtc in matchers
where !udf.Matchers.Any(m => m.Name.Equals(mtc.Name))
select mtc;
return(View(mtcs));
}
else
{
//TODO replace with default view (List)
return(RedirectToAction(nameof(PropertyKeyController.Create)));
}
}
public async Task <ActionResult> Edit(BlobContentViewModel model, string updateButton)
{
if (updateButton.Equals("Cancel"))
{
return(Redirect(CacheHelper.GetPreviousPage(_cache)));
}
try
{
model.SelectedBlobContentItem.Sharing = "None";
await DigitalTwinsHelper.CreateOrUpdateBlob(
model.SelectedBlobContentItem.ParentType,
model.SelectedBlobContentItem,
model.File,
_cache,
Loggers.SilentLogger);
return(Redirect(CacheHelper.GetPreviousPage(_cache)));
}
catch (Exception ex)
{
await FeedbackHelper.Channel.SendMessageAsync(ex.Message, MessageType.Info);
return(View(model));
}
}
public async Task <ActionResult> Delete(SpaceViewModel model, string updateButton)
{
if (updateButton.Equals("Cancel"))
{
return(Redirect(CacheHelper.GetPreviousPage(_cache)));
}
try
{
if (await DigitalTwinsHelper.DeleteSpaceAsync(model.SelectedSpaceItem, _cache, Loggers.SilentLogger))
{
return(Redirect(CacheHelper.GetPreviousPage(_cache)));
}
else
{
model = new SpaceViewModel(_cache, model.SelectedSpaceItem.Id);
return(View(model));
}
}
catch (Exception ex)
{
await FeedbackHelper.Channel.SendMessageAsync(ex.InnerException.ToString(), MessageType.Info);
return(View());
}
}
private async Task LoadAsync(Guid?id = null)
{
SpaceList = new List <Space>();
SpaceList.Add(new Space()
{
Id = Guid.Empty, Name = "None"
});
SpaceList.AddRange(await DigitalTwinsHelper.GetSpacesAsync(_cache, Loggers.SilentLogger));
//SpaceList = await DigitalTwinsHelper.GetSpacesAsync(_cache, Loggers.SilentLogger);
SpaceTypeList = await DigitalTwinsHelper.GetTypesAsync(Models.Types.SpaceType, _cache, Loggers.SilentLogger, onlyEnabled : true);
SpaceSubTypeList = await DigitalTwinsHelper.GetTypesAsync(Models.Types.SpaceSubtype, _cache, Loggers.SilentLogger, onlyEnabled : true);
SpaceStatusList = await DigitalTwinsHelper.GetTypesAsync(Models.Types.SpaceStatus, _cache, Loggers.SilentLogger, onlyEnabled : true);
if (id != null)
{
this.SelectedSpaceItem = await DigitalTwinsHelper.GetSpaceAsync((Guid)id, _cache, Loggers.SilentLogger, false);
this.UDFList = await DigitalTwinsHelper.GetUDFsBySpaceIdAsync((Guid)id, _cache, Loggers.SilentLogger, false);
this.Blobs = await DigitalTwinsHelper.GetBlobsAsync((Guid)id, _cache, Loggers.SilentLogger, true);
this.AvailableProperties = await DigitalTwinsHelper.GetPropertyKeysForSpace((Guid)id, _cache, Loggers.SilentLogger);
}
else
{
this.SelectedSpaceItem = new Space();
this.UDFList = new List <UserDefinedFunction>();
this.Blobs = new List <BlobContent>();
this.AvailableProperties = new List <PropertyKey>();
}
}
private async Task LoadAsync(Models.Types?filterType)
{
List <Ontology> ontologies = await DigitalTwinsHelper.GetOntologiesWithTypes(_cache, Loggers.SilentLogger);
List <Ontology> filteredOntologies = new List <Ontology>();
Ontology ontology;
foreach (Ontology item in ontologies)
{
ontology = new Ontology()
{
Id = item.Id, Name = item.Name, Loaded = item.Loaded
};
if (filterType != null)
{
ontology.types = item.types.FindAll(t => t.Category.Equals(filterType.ToString()));
}
else
{
ontology.types = item.types;
}
filteredOntologies.Add(ontology);
}
OntologyList = filteredOntologies;
}
private async Task MergeTree(PropertyKey propertyKey, IEnumerable <Guid> spacePath, int level)
{
level++;
Guid spaceId = spacePath.First();
Space space = await DigitalTwinsHelper.GetSpaceAsync(spaceId, _cache, Loggers.SilentLogger);
if (spacePath.Count() == 1)
{
if (!space.PropertyKeys.Exists(p => p.Id == propertyKey.Id))
{
space.PropertyKeys.Add(propertyKey);
}
}
if (!spaces.Exists(s => s.Space.Id == space.Id))
{
int index = spaces.FindIndex(s => s.Space.Id == space.ParentSpaceId);
spaces.Insert(index + 1, new UISpace()
{
Space = space, MarginLeft = $"{25 * level-1}px"
});
}
else
{
spaces.First(s => s.Space.Id == space.Id).Space = space;
}
if (spacePath.Count() > 1)
{
await MergeTree(propertyKey, spacePath.Skip(1), level);
}
}
public async Task <ActionResult> SimulatorAction(SimulatorViewModel model, string Action)
{
if (Action.Equals("Cancel"))
{
return(Redirect(CacheHelper.GetPreviousPage(_cache)));
}
if (model.SelectedDevice == Guid.Empty)
{
await FeedbackHelper.Channel.SendMessageAsync("No connection string added to connect to Azure IoT Hub", MessageType.Info);
return(RedirectToAction(nameof(Index)));
}
else
{
var device = await DigitalTwinsHelper.GetDeviceAsync(model.SelectedDevice, _cache, Loggers.SilentLogger, false);
try
{
if (Action.Equals("Launch") && !CacheHelper.IsInSendingDataState(_cache))
{
var list = await CacheHelper.GetSimulatedSensorListFromCacheAsync(_cache);
if (list != null && list.Count > 0)
{
CacheHelper.SetInSendingDataState(_cache, true);
try
{
await SendDataAsync(device.ConnectionString);
}
catch (Exception)
{
await FeedbackHelper.Channel.SendMessageAsync("Error during sending", MessageType.Info);
}
CacheHelper.SetInSendingDataState(_cache, false);
}
else
{
await FeedbackHelper.Channel.SendMessageAsync("No sensor defined to send data", MessageType.Info);
}
}
else if (Action.Equals("Stop"))
{
await FeedbackHelper.Channel.SendMessageAsync("Stopping sending data...", MessageType.Info);
CacheHelper.SetInSendingDataState(_cache, false);
}
}
catch (Exception ex)
{
FeedbackHelper.Channel.SendMessageAsync($"Error - {ex.Message}", MessageType.Info).Wait();
}
return(RedirectToAction(nameof(Index)));
}
}
internal async Task LoadAsync(Guid?id = null)
{
SpaceList = new List <Space>();
SpaceList.Add(new Space()
{
Name = "None", Id = Guid.Empty
});
SpaceList.AddRange(await DigitalTwinsHelper.GetSpacesAsync(_cache, Loggers.SilentLogger));
}
private async Task LoadAsync()
{
SpaceTypeList = new List <Models.Type>();
SpaceTypeList.Add(new Models.Type()
{
Name = "All"
});
SpaceTypeList.AddRange(await DigitalTwinsHelper.GetTypesAsync(Models.Types.SpaceType, _cache, Loggers.SilentLogger, onlyEnabled: true));
}
private async Task LoadAsync()
{
SpaceList = await DigitalTwinsHelper.GetSpacesAsync(_cache, Loggers.SilentLogger);
DataTypeList = await DigitalTwinsHelper.GetTypesAsync(Models.Types.SensorDataType, _cache, Loggers.SilentLogger, onlyEnabled : true);
DataUnitTypeList = await DigitalTwinsHelper.GetTypesAsync(Models.Types.SensorDataUnitType, _cache, Loggers.SilentLogger, onlyEnabled : true);
DataSubTypeList = await DigitalTwinsHelper.GetTypesAsync(Models.Types.SensorDataSubtype, _cache, Loggers.SilentLogger, onlyEnabled : true);
}
public async Task <ActionResult> Edit(Guid id)
{
CacheHelper.SetPreviousPage(_cache, Request.Headers["Referer"].ToString());
var udf = await DigitalTwinsHelper.GetUserDefinedFunction(id, _cache, Loggers.SilentLogger, false);
var viewModel = new UDFViewModel(_cache, udf);
return(View(viewModel));
}
private async Task LoadAsync(Guid?id = null)
{
SpaceList = await DigitalTwinsHelper.GetSpacesAsync(_cache, Loggers.SilentLogger);
DeviceTypeList = await DigitalTwinsHelper.GetTypesAsync(Models.Types.DeviceType, _cache, Loggers.SilentLogger, onlyEnabled : true);
DeviceSubTypeList = await DigitalTwinsHelper.GetTypesAsync(Models.Types.DeviceSubtype, _cache, Loggers.SilentLogger, onlyEnabled : true);
if (id != null)
{
this.SelectedDeviceItem = await DigitalTwinsHelper.GetDeviceAsync((Guid)id, _cache, Loggers.SilentLogger, false);
}
}
public async Task <ActionResult> Delete(MatcherViewModel model, string updateButton)
{
string previousPage = CacheHelper.GetPreviousPage(_cache);
if (updateButton.Equals("Cancel"))
{
return(Redirect(previousPage));
}
await DigitalTwinsHelper.DeleteMatcherAsync(model.SelectedMatcher, _cache, Loggers.SilentLogger);
return(RedirectToAction("Edit", "UDF", new { id = model.UdfId }));
}
public async Task <ActionResult> Search(SpacesViewModel model)
{
var searchString = model.SearchString;
var searchType = model.SearchType;
model = new SpacesViewModel(_cache);
int searchTypeId = searchType.Equals("All") ? -1 : model.SpaceTypeList.Single(t => t.Name.Equals(searchType)).Id;
model.SpaceList = await DigitalTwinsHelper.SearchSpacesAsync(_cache, Loggers.SilentLogger, searchString, searchTypeId);
return(View("List", model));
}
public async Task <ActionResult> AddCondition(MatcherViewModel model, string createButton)
{
string previousPage = CacheHelper.GetPreviousPage(_cache);
var matcher = await DigitalTwinsHelper.GetMatcherAsync(model.SelectedMatcher.Id, _cache, Loggers.SilentLogger, false);
if (matcher != null)
{
matcher.Conditions.Add(model.SelectedMatcherCondition);
CacheHelper.AddInCache(_cache, matcher, matcher.Id, Context.Matcher);
}
return(Redirect(previousPage));
}
public async Task <ActionResult> Create(SpaceViewModel model, string createButton)
{
string previousPage = CacheHelper.GetPreviousPage(_cache);
if (createButton.Equals("Cancel"))
{
return(Redirect(previousPage));
}
if (ModelState.IsValid)
{
try
{
var spaceResult = await DigitalTwinsHelper.CreateSpaceAsync(model.SelectedSpaceItem, _cache, Loggers.SilentLogger);
switch (createButton)
{
case "Save & Close":
return(Redirect(previousPage));
case "Save & Create another":
return(RedirectToAction(nameof(Create)));
case "Save & Edit":
if (spaceResult.Id != Guid.Empty)
{
return(RedirectToAction(nameof(Edit), new { id = spaceResult.Id }));
}
else
{
return(Redirect(previousPage));
}
default:
return(RedirectToAction(nameof(List)));
}
}
catch (Exception ex)
{
await FeedbackHelper.Channel.SendMessageAsync(ex.Message, MessageType.Info);
model = new SpaceViewModel(_cache);
return(View(model));
}
}
else
{
return(View("Create"));
}
}
private async Task LoadAsync(Guid?id = null)
{
switch (_parentType)
{
case ParentType.Space:
{
BlobContentTypeList = await DigitalTwinsHelper.GetTypesAsync(
Models.Types.SpaceBlobType, _cache, Loggers.SilentLogger, onlyEnabled : true);
BlobContentSubTypeList = await DigitalTwinsHelper.GetTypesAsync(
Models.Types.SpaceBlobSubtype, _cache, Loggers.SilentLogger, onlyEnabled : true);
break;
}
case ParentType.Device:
{
BlobContentTypeList = await DigitalTwinsHelper.GetTypesAsync(
Models.Types.DeviceBlobType, _cache, Loggers.SilentLogger, onlyEnabled : true);
BlobContentSubTypeList = await DigitalTwinsHelper.GetTypesAsync(
Models.Types.DeviceBlobSubtype, _cache, Loggers.SilentLogger, onlyEnabled : true);
break;
}
case ParentType.Sensor:
{
BlobContentTypeList = await DigitalTwinsHelper.GetTypesAsync(
Models.Types.SensorDataType, _cache, Loggers.SilentLogger, onlyEnabled : true);
BlobContentSubTypeList = await DigitalTwinsHelper.GetTypesAsync(
Models.Types.DeviceBlobSubtype, _cache, Loggers.SilentLogger, onlyEnabled : true);
break;
}
}
if (id != null)
{
this.SelectedBlobContentItem = await DigitalTwinsHelper.GetBlobAsync((Guid)id, _cache, Loggers.SilentLogger, true);
}
else
{
SelectedBlobContentItem = new BlobContent();
}
this.SelectedBlobContentItem.ParentType = _parentType;
}
public async Task <ActionResult> List()
{
CacheHelper.SetPreviousPage(_cache, Request.Headers["Referer"].ToString());
var model = new SpacesViewModel(_cache);
try
{
model.SpaceList = await DigitalTwinsHelper.GetRootSpacesAsync(_cache, Loggers.SilentLogger, false);
}
catch (Exception ex)
{
FeedbackHelper.Channel.SendMessageAsync($"Error - {ex.Message}", MessageType.Info).Wait();
}
return(View(model));
}
public async Task <ActionResult> Delete(UDFViewModel model, string updateButton)
{
if (updateButton.Equals("Cancel"))
{
return(Redirect(CacheHelper.GetPreviousPage(_cache)));
}
try
{
await DigitalTwinsHelper.DeleteUserDefinedFunctionAsync(model.UDF, _cache, Loggers.SilentLogger);
return(RedirectToAction("List", "UDF"));
}
catch
{
return(View());
}
}
public async Task <ActionResult> Edit(SensorViewModel model, string updateButton)
{
if (updateButton.Equals("Cancel"))
{
return(Redirect(CacheHelper.GetPreviousPage(_cache)));
}
try
{
await DigitalTwinsHelper.UpdateSensorAsync(model.SelectedSensor, _cache, Loggers.SilentLogger);
return(Redirect(CacheHelper.GetPreviousPage(_cache)));
}
catch (Exception ex)
{
await FeedbackHelper.Channel.SendMessageAsync(ex.InnerException.ToString(), MessageType.Info);
return(View());
}
}
private async Task LoadAsync(string id)
{
SpaceList = await DigitalTwinsHelper.GetSpacesAsync(_cache, Loggers.SilentLogger);
PrimitiveDataTypeList = new List <string>();
PrimitiveDataTypeList.Add("Bool");
PrimitiveDataTypeList.Add("String");
PrimitiveDataTypeList.Add("Long");
PrimitiveDataTypeList.Add("Int");
PrimitiveDataTypeList.Add("Uint");
PrimitiveDataTypeList.Add("DateTime");
PrimitiveDataTypeList.Add("Set");
PrimitiveDataTypeList.Add("Enum");
PrimitiveDataTypeList.Add("Json");
if (id != null)
{
this.SelectedPropertyKey = await DigitalTwinsHelper.GetPropertyKeyAsync(id, _cache, Loggers.SilentLogger, false);
}
}
public async Task <ActionResult> Create(UDFViewModel model, string updateButton)
{
if (updateButton.Equals("Cancel"))
{
return(Redirect(CacheHelper.GetPreviousPage(_cache)));
}
try
{
string js;
if (model.UDFFile != null)
{
using (var r = new StreamReader(model.UDFFile.OpenReadStream()))
{
js = await r.ReadToEndAsync();
if (String.IsNullOrWhiteSpace(js))
{
await FeedbackHelper.Channel.SendMessageAsync($"Error - We cannot read the content of the file {model.UDFFile.FileName}.", MessageType.Info);
}
}
}
else if (model.Content != null)
{
js = model.Content;
}
else
{
js = string.Empty;
}
var id = await DigitalTwinsHelper.CreateUserDefinedFunctionAsync(_cache, Loggers.SilentLogger, model.UDF, js);
return(RedirectToAction(nameof(Edit), new { id = id }));
}
catch
{
return(Redirect(CacheHelper.GetPreviousPage(_cache)));
}
}
public async Task <IActionResult> Remove(Guid spaceId, string name)
{
if (spaceId != Guid.Empty && name != null && name != string.Empty)
{
Space space = await DigitalTwinsHelper.GetSpaceAsync((Guid)spaceId, _cache, Loggers.SilentLogger);
var prop = space.Properties.FirstOrDefault(p => p.Name.Equals(name));
if (prop != null)
{
space.Properties.Remove(prop);
await DigitalTwinsHelper.UpdateSpaceAsync(space, _cache, Loggers.SilentLogger);
}
return(Redirect(Request.Headers["Referer"].ToString()));
}
else
{
//TODO replace with default view (List)
return(RedirectToAction(nameof(PropertyKeyController.Create)));
}
}
public async Task <ActionResult> Create(SensorViewModel model, string updateButton)
{
if (updateButton.Equals("Cancel"))
{
return(Redirect(CacheHelper.GetPreviousPage(_cache)));
}
try
{
var id = await DigitalTwinsHelper.CreateSensorAsync(model.SelectedSensor, _cache, Loggers.SilentLogger);
await FeedbackHelper.Channel.SendMessageAsync($"Sensor with id '{id}' successfully created.", MessageType.Info);
return(Redirect(CacheHelper.GetPreviousPage(_cache)));
}
catch (Exception ex)
{
await FeedbackHelper.Channel.SendMessageAsync(ex.Message, MessageType.Info);
return(View());
}
}
