public IActionResult Edit([Required] string deviceId, [Required] string traitId)
{
if (!_deviceRepository.Contains(deviceId))
{
return(NotFound());
}
var device = _deviceRepository.Get(deviceId);
var traitEnumId = traitId.ToEnum <TraitType>();
if (!device.Traits.Any(x => x.Trait == traitEnumId))
{
return(NotFound());
}
// Get trait
var trait = device.Traits.First(x => x.Trait == traitEnumId);
var model = new TraitViewModel
{
Trait = trait.Trait,
Attributes = trait.Attributes != null?JsonConvert.SerializeObject(trait.Attributes, Formatting.Indented) : null,
Commands = trait.Commands != null?JsonConvert.SerializeObject(trait.Commands, Formatting.Indented) : null,
State = trait.State != null?JsonConvert.SerializeObject(trait.State, Formatting.Indented) : null
};
return(View(model));
}
public IActionResult Create([Required] string deviceId, TraitViewModel viewModel)
{
if (!_deviceRepository.Contains(deviceId))
{
return(NotFound());
}
var device = _deviceRepository.Get(deviceId);
if (device.Traits.Any(x => x.Trait == viewModel.Trait))
{
ModelState.AddModelError("Trait", "Device already contains trait");
}
if (!ModelState.IsValid)
{
return(RedirectToAction("Create", new { deviceId }));
}
// Set values
var trait = new DeviceTrait
{
Trait = viewModel.Trait,
Attributes = !string.IsNullOrEmpty(viewModel.Attributes) ? JsonConvert.DeserializeObject <Dictionary <string, object> >(viewModel.Attributes, new ObjectDictionaryConverter()) : null,
Commands = !string.IsNullOrEmpty(viewModel.Commands) ? JsonConvert.DeserializeObject <Dictionary <string, IDictionary <string, string> > >(viewModel.Commands) : null,
State = !string.IsNullOrEmpty(viewModel.State) ? JsonConvert.DeserializeObject <Dictionary <string, DeviceState> >(viewModel.State) : null
};
device.Traits.Add(trait);
// Save changes
_deviceRepository.Persist();
return(RedirectToAction("Edit", "Devices", new { deviceId }));
}
public IActionResult Create([Required] string deviceId, TraitViewModel viewModel)
{
if (!_deviceRepository.Contains(deviceId))
{
return(NotFound());
}
var device = _deviceRepository.GetDetached(deviceId);
if (device.Traits.Any(x => x.Trait == viewModel.Trait))
{
ModelState.AddModelError("Trait", "Device already contains trait");
}
// Set values
var trait = new DeviceTrait
{
Trait = viewModel.Trait,
Attributes = !string.IsNullOrEmpty(viewModel.Attributes) ? JsonConvert.DeserializeObject <Dictionary <string, object> >(viewModel.Attributes, new ObjectDictionaryConverter()) : null,
Commands = !string.IsNullOrEmpty(viewModel.Commands) ? JsonConvert.DeserializeObject <Dictionary <string, IDictionary <string, string> > >(viewModel.Commands) : new Dictionary <string, IDictionary <string, string> >(),
State = !string.IsNullOrEmpty(viewModel.State) ? JsonConvert.DeserializeObject <Dictionary <string, DeviceState> >(viewModel.State) : null
};
// Handle any challenges
switch (viewModel.ChallengeType)
{
case ChallengeType.Acknowledge:
trait.Challenge = new AcknowledgeChallenge();
break;
case ChallengeType.Pin:
trait.Challenge = new PinChallenge
{
Pin = viewModel.ChallengePin
};
break;
case ChallengeType.None:
default:
trait.Challenge = null;
break;
}
// Final validation
foreach (var error in DeviceTraitValidator.Validate(trait))
{
ModelState.AddModelError(string.Empty, error);
}
if (!ModelState.IsValid)
{
return(RedirectToAction("Create", new { deviceId }));
}
// Save changes
device.Traits.Add(trait);
_deviceRepository.Update(deviceId, device);
return(RedirectToAction("Edit", "GoogleDevice", new { deviceId }));
}
public IActionResult Create([Required] string deviceId)
{
if (!_deviceRepository.Contains(deviceId))
{
return(NotFound());
}
var model = new TraitViewModel();
return(View(model));
}
public TraitViewModel GetOrAdd(string text)
{
var index = this.Collection.BinarySearch(text, StringComparer.Ordinal, vm => vm.Text);
if (index < 0)
{
var viewModel = new TraitViewModel(text);
this.Collection.Insert(~index, viewModel);
return viewModel;
}
return this.Collection[index];
}
public IActionResult Edit([Required] string deviceId, [Required] string traitId)
{
if (!_deviceRepository.Contains(deviceId))
{
return(NotFound());
}
var device = _deviceRepository.Get(deviceId);
var traitEnumId = traitId.ToEnum <TraitType>();
if (!device.Traits.Any(x => x.Trait == traitEnumId))
{
return(NotFound());
}
ViewBag.SupportedTraits = DeviceMetadata.SupportedTraits.TryGetValue(device.Type, out IList <TraitType> supportedDevices)
? supportedDevices.Select(x => new SelectListItem {
Text = x.ToString(), Value = ((int)x).ToString(), Selected = traitEnumId == x
})
: Enumerable.Empty <SelectListItem>();
// Get trait
var trait = device.Traits.First(x => x.Trait == traitEnumId);
var model = new TraitViewModel
{
Trait = trait.Trait,
Attributes = trait.Attributes != null?JsonConvert.SerializeObject(trait.Attributes, Formatting.Indented) : null,
Commands = trait.Commands != null?JsonConvert.SerializeObject(trait.Commands, Formatting.Indented) : null,
State = trait.State != null?JsonConvert.SerializeObject(trait.State, Formatting.Indented) : null
};
// Handle any challenges
switch (trait.Challenge)
{
case AcknowledgeChallenge ackChallenge:
model.ChallengeType = ChallengeType.Acknowledge;
break;
case PinChallenge pinChallenge:
model.ChallengeType = ChallengeType.Pin;
model.ChallengePin = pinChallenge.Pin;
break;
default:
model.ChallengeType = ChallengeType.None;
break;
}
return(View(model));
}
public TraitElementControl(User user, TraitViewModel model, TraitCategoryType categoryType)
{
this.Model = model;
DataContext = model;
InitializeComponent();
txtValue.BindUser(user, PickListType.DistinctTraitList, model.Name, categoryType);
if (!String.IsNullOrEmpty(model.Comment)) {
commentLink.Inlines.Clear();
commentLink.Inlines.Add(new Run("Edit comment"));
}
Model.DataChanged += new DataChangedHandler((vm) => {
FireTraitChanged();
});
}
public ActionResult Details(int?id)
{
if (!id.HasValue)
{
return(RedirectToAction("Index"));
}
var genus = m_repo.GetGenus(id.Value);
var traitViewModel = new TraitViewModel
{
Genus = genus,
RetiredQuestions = genus.Questions.Where(t => t.Retired == true).OrderBy(t => t.Order),
ActiveQuestions = genus.Questions.Where(t => t.Retired == false).OrderBy(t => t.Order)
};
return(View(traitViewModel));
}
public IActionResult Edit([Required] string deviceId, [Required] string traitId)
{
if (!_deviceRepository.Contains(deviceId))
{
return(NotFound());
}
var device = _deviceRepository.Get(deviceId);
var traitEnumId = traitId.ToEnum <TraitType>();
if (!device.Traits.Any(x => x.Trait == traitEnumId))
{
return(NotFound());
}
// Get trait
var trait = device.Traits.First(x => x.Trait == traitEnumId);
var model = new TraitViewModel
{
Trait = trait.Trait,
Attributes = trait.Attributes != null?JsonConvert.SerializeObject(trait.Attributes, Formatting.Indented) : null,
Commands = trait.Commands != null?JsonConvert.SerializeObject(trait.Commands, Formatting.Indented) : null,
State = trait.State != null?JsonConvert.SerializeObject(trait.State, Formatting.Indented) : null
};
// Handle any challenges
switch (trait.Challenge)
{
case AcknowledgeChallenge ackChallenge:
model.ChallengeType = ChallengeType.Acknowledge;
break;
case PinChallenge pinChallenge:
model.ChallengeType = ChallengeType.Pin;
model.ChallengePin = pinChallenge.Pin;
break;
default:
model.ChallengeType = ChallengeType.None;
break;
}
return(View(model));
}
public IActionResult Create([Required] string deviceId)
{
if (!_deviceRepository.Contains(deviceId))
{
return(NotFound());
}
var device = _deviceRepository.Get(deviceId);
ViewBag.SupportedTraits = DeviceMetadata.SupportedTraits.TryGetValue(device.Type, out IList <TraitType> supportedDevices)
? supportedDevices.Select(x => new SelectListItem {
Text = x.ToString(), Value = ((int)x).ToString()
})
: Enumerable.Empty <SelectListItem>();
var model = new TraitViewModel();
return(View(model));
}
public IActionResult Edit([Required] string deviceId, [Required] string traitId, TraitViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Edit", new { deviceId, traitId }));
}
if (!_deviceRepository.Contains(deviceId))
{
return(NotFound());
}
var device = _deviceRepository.Get(deviceId);
var traitEnumId = traitId.ToEnum <TraitType>();
if (!device.Traits.Any(x => x.Trait == traitEnumId))
{
return(NotFound());
}
// Lock the trait type just in case
viewModel.Trait = traitEnumId;
// Set new values
var trait = device.Traits.FirstOrDefault(x => x.Trait == traitEnumId);
trait.Attributes = !string.IsNullOrEmpty(viewModel.Attributes) ? JsonConvert.DeserializeObject <Dictionary <string, object> >(viewModel.Attributes, new ObjectDictionaryConverter()) : null;
trait.Commands = !string.IsNullOrEmpty(viewModel.Commands) ? JsonConvert.DeserializeObject <Dictionary <string, IDictionary <string, string> > >(viewModel.Commands) : null;
trait.State = !string.IsNullOrEmpty(viewModel.State) ? JsonConvert.DeserializeObject <Dictionary <string, DeviceState> >(viewModel.State) : null;
// Save changes
_deviceRepository.Persist();
return(RedirectToAction("Edit", "Devices", new { deviceId }));
}
public IActionResult Edit([Required] string deviceId, [Required] string traitId, TraitViewModel viewModel)
{
if (!_deviceRepository.Contains(deviceId))
{
return(NotFound());
}
var device = _deviceRepository.GetDetached(deviceId);
var traitEnumId = traitId.ToEnum <TraitType>();
if (!device.Traits.Any(x => x.Trait == traitEnumId))
{
return(NotFound());
}
// Lock the trait type just in case
viewModel.Trait = traitEnumId;
if (DeviceMetadata.SupportedTraits.TryGetValue(device.Type, out IList <TraitType> supportedTraits) && !supportedTraits.Contains(viewModel.Trait))
{
ModelState.AddModelError("Trait", "Device does not support trait type");
}
// Set new values
var trait = device.Traits.FirstOrDefault(x => x.Trait == traitEnumId);
trait.Attributes = !string.IsNullOrEmpty(viewModel.Attributes) ? JsonConvert.DeserializeObject <Dictionary <string, object> >(viewModel.Attributes, new ObjectDictionaryConverter()) : null;
trait.Commands = !string.IsNullOrEmpty(viewModel.Commands) ? JsonConvert.DeserializeObject <Dictionary <string, IDictionary <string, string> > >(viewModel.Commands) : null;
trait.State = !string.IsNullOrEmpty(viewModel.State) ? JsonConvert.DeserializeObject <Dictionary <string, DeviceState> >(viewModel.State) : null;
// Handle any challenges
switch (viewModel.ChallengeType)
{
case ChallengeType.Acknowledge:
trait.Challenge = new AcknowledgeChallenge();
break;
case ChallengeType.Pin:
trait.Challenge = new PinChallenge
{
Pin = viewModel.ChallengePin
};
break;
case ChallengeType.None:
default:
trait.Challenge = null;
break;
}
// Final validation
foreach (var error in DeviceTraitValidator.Validate(trait))
{
ModelState.AddModelError(string.Empty, error);
}
if (!ModelState.IsValid)
{
return(RedirectToAction("Edit", new { deviceId, traitId }));
}
// Save changes
_deviceRepository.Update(deviceId, device);
return(RedirectToAction("Edit", "GoogleDevice", new { deviceId }));
}
private void SelectTrait(TraitViewModel vm)
{
// find the trait editor for the selected trait...
foreach (TraitElementControl ctl in traitsPanel.Children) {
if (ctl.Model == vm) {
if (!ctl.txtValue.IsLoaded) {
ctl.txtValue.txt.Loaded += new RoutedEventHandler((source, e) => {
Keyboard.Focus(ctl.txtValue.txt);
});
} else {
Keyboard.Focus(ctl.txtValue.txt);
}
return;
}
}
}
private void AddTraitEditor(TraitViewModel model)
{
var itemControl = new TraitElementControl(User, model, TraitCategory);
itemControl.TraitChanged += new TraitElementControl.TraitEventHandler((source, trait) => {
RegisterUniquePendingChange(new UpdateTraitDatabaseCommand(trait.Model, Owner));
});
itemControl.TraitDeleted += new TraitElementControl.TraitEventHandler((source, trait) => {
_model.Remove(trait);
ReloadTraitPanel();
RegisterPendingChange(new DeleteTraitDatabaseCommand(trait.Model, Owner));
});
itemControl.IsReadOnly = this.IsReadOnly;
traitsPanel.Children.Add(itemControl);
}
private void AddNewTrait()
{
var service = new SupportService(User);
List<String> traitTypes = service.GetTraitNamesForCategory(TraitCategory.ToString());
var picklist = new PickListWindow(User, "Choose a trait type...", () => {
return traitTypes;
}, (text) => {
traitTypes.Add(text);
return true;
});
picklist.Owner = this.FindParentWindow();
if (picklist.ShowDialog().ValueOrFalse()) {
var existing = FindTraitByName(picklist.SelectedValue as string);
if (existing == null) {
Trait t = new Trait();
t.TraitID = -1;
t.Value = "<New Trait Value>";
t.Category = TraitCategory.ToString();
t.IntraCatID = Owner.ObjectID.Value;
t.Name = picklist.SelectedValue as string;
TraitViewModel viewModel = new TraitViewModel(t);
_model.Add(viewModel);
RegisterUniquePendingChange(new UpdateTraitDatabaseCommand(t, Owner));
ReloadTraitPanel();
SelectTrait(viewModel);
} else {
SelectTrait(existing);
}
}
}
