DarthAffe/Artemis
1
0
Fork 0
mirror of https://github.com/Artemis-RGB/Artemis synced 2025-12-13 05:48:35 +00:00
Code Issues Releases Wiki Activity

Datamodel - Simplified some things

Browse Source
This commit is contained in:
Robert 2020-06-26 23:05:30 +02:00
parent 9b09942bda
commit 291a343428
10 changed files with 111 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/Artemis.Core/Attributes/DataModelProperty.cs
View File

@ -1,9 +0,0 @@
using System;
namespace Artemis.Core.Attributes
{
public class DataModelPropertyAttribute : Attribute
{
public string DisplayName { get; set; }
}
}

6
src/Artemis.Core/Models/DataModelDescription.cs
View File

@ -1,6 +0,0 @@
namespace Artemis.Core.Models
{
public class DataModelDescription
{
}
}

8
src/Artemis.Core/Plugins/Abstract/DataModels/Attributes/DataModelIgnoreAttribute.cs Normal file
View File

@ -0,0 +1,8 @@
using System;
namespace Artemis.Core.Plugins.Abstract.DataModels.Attributes
{
public class DataModelIgnoreAttribute : Attribute
{
}
}

53
src/Artemis.Core/Plugins/Abstract/DataModels/DataModel.cs
View File

@ -1,11 +1,5 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Artemis.Core.Exceptions;
using Artemis.Core.Plugins.Abstract.DataModels.Attributes;
using Artemis.Core.Plugins.Exceptions;
using Artemis.Core.Plugins.Abstract.DataModels.Attributes;
using Artemis.Core.Plugins.Models;
using SkiaSharp;
namespace Artemis.Core.Plugins.Abstract.DataModels
{
@ -16,54 +10,9 @@ namespace Artemis.Core.Plugins.Abstract.DataModels
/// </summary>
public PluginInfo PluginInfo { get; internal set; }
/// <summary>
/// Gets whether this data model is initialized
/// </summary>
public bool Initialized { get; private set; }
/// <summary>
/// Gets the <see cref="DataModelPropertyAttribute" /> describing this data model
/// </summary>
public DataModelPropertyAttribute DataModelDescription { get; internal set; }
/// <summary>
/// If found on this type, returns the <see cref="DataModelPropertyAttribute" /> for the provided property name
/// </summary>
/// <param name="propertyName">The name of the property on to look for</param>
public DataModelPropertyAttribute GetPropertyAttribute(string propertyName)
{
var propertyInfo = GetType().GetProperty(propertyName);
if (propertyInfo == null)
return null;
return (DataModelPropertyAttribute) Attribute.GetCustomAttribute(propertyInfo, typeof(DataModelPropertyAttribute));
}
internal void Initialize()
{
// Doubt this will happen but let's make sure
if (Initialized)
throw new ArtemisCoreException("Data model already initialized, wut");
foreach (var propertyInfo in GetType().GetProperties())
{
var dataModelPropertyAttribute = (DataModelPropertyAttribute) Attribute.GetCustomAttribute(propertyInfo, typeof(DataModelPropertyAttribute));
if (dataModelPropertyAttribute == null || !typeof(DataModel).IsAssignableFrom(propertyInfo.PropertyType))
continue;
// If the property is a nested datamodel create an instance and initialize it
var instance = (DataModel) Activator.CreateInstance(propertyInfo.PropertyType, true);
if (instance == null)
throw new ArtemisCoreException($"Failed to create instance of child datamodel at {propertyInfo.Name}");
instance.PluginInfo = PluginInfo;
instance.DataModelDescription = dataModelPropertyAttribute;
instance.Initialize();
propertyInfo.SetValue(this, instance);
}
Initialized = true;
}
}
}

15
src/Artemis.Core/Services/DataModelService.cs
View File

@ -61,37 +61,26 @@ namespace Artemis.Core.Services
}
}
public DataModelDescription GetMainDataModelDescription()
{
var dataModelDescription = new DataModelDescription();
return dataModelDescription;
}
private void PluginServiceOnPluginEnabled(object sender, PluginEventArgs e)
{
if (e.PluginInfo.Instance is Module module && module.InternalExpandsMainDataModel)
{
if (!module.InternalDataModel.Initialized)
if (module.InternalDataModel.DataModelDescription == null)
{
module.InternalDataModel.DataModelDescription = module.InternalGetDataModelDescription();
if (module.InternalDataModel.DataModelDescription == null)
throw new ArtemisPluginException(module.PluginInfo, "Module overrides GetDataModelDescription but returned null");
module.InternalDataModel.Initialize();
}
_dataModelExpansions.Add(module.InternalDataModel);
}
else if (e.PluginInfo.Instance is BaseDataModelExpansion dataModelExpansion)
{
if (!dataModelExpansion.InternalDataModel.Initialized)
if (dataModelExpansion.InternalDataModel.DataModelDescription == null)
{
dataModelExpansion.InternalDataModel.DataModelDescription = dataModelExpansion.GetDataModelDescription();
if (dataModelExpansion.InternalDataModel.DataModelDescription == null)
throw new ArtemisPluginException(dataModelExpansion.PluginInfo, "Data model expansion overrides GetDataModelDescription but returned null");
dataModelExpansion.InternalDataModel.Initialize();
}
_dataModelExpansions.Add(dataModelExpansion.InternalDataModel);

11
src/Artemis.Core/Services/Interfaces/IDataModelService.cs
View File

@ -1,10 +1,13 @@
using Artemis.Core.Models;
using System.Collections.ObjectModel;
using Artemis.Core.Models;
using Artemis.Core.Plugins.Abstract.DataModels;
namespace Artemis.Core.Services.Interfaces
{
public interface IDataModelService : IArtemisService
{
ReadOnlyCollection<DataModel> DataModelExpansions { get; }
/// <summary>
/// Add an expansion to the datamodel to be available for use after the next update
/// </summary>
@ -16,11 +19,5 @@ namespace Artemis.Core.Services.Interfaces
/// </summary>
/// <param name="baseDataModelExpansion"></param>
void RemoveExpansion(DataModel baseDataModelExpansion);
/// <summary>
/// Generates a data model description for the main datamodel including all it's expansions
/// </summary>
/// <returns>The generated data model description</returns>
DataModelDescription GetMainDataModelDescription();
}
}

11
src/Artemis.UI/DataModelVisualization/DataModelGroupViewModel.cs Normal file
View File

@ -0,0 +1,11 @@
using Artemis.Core.Plugins.Abstract.DataModels.Attributes;
using Stylet;
namespace Artemis.UI.DataModelVisualization
{
public abstract class DataModelVisualizationViewModel : PropertyChangedBase
{
public DataModelPropertyAttribute PropertyDescription { get; protected set; }
public DataModelViewModel Parent { get; protected set; }
}
}

23
src/Artemis.UI/DataModelVisualization/DataModelPropertyViewModel.cs Normal file
View File

@ -0,0 +1,23 @@
using System.Reflection;
using Artemis.Core.Plugins.Abstract.DataModels.Attributes;
using FastMember;
namespace Artemis.UI.DataModelVisualization
{
public class DataModelPropertyViewModel : DataModelVisualizationViewModel
{
private readonly ObjectAccessor _accessor;
public DataModelPropertyViewModel(PropertyInfo propertyInfo, DataModelPropertyAttribute propertyDescription, DataModelViewModel parent)
{
_accessor = ObjectAccessor.Create(parent.Model);
PropertyInfo = propertyInfo;
Parent = parent;
PropertyDescription = propertyDescription;
}
public PropertyInfo PropertyInfo { get; }
public object Value => _accessor[PropertyInfo.Name];
}
}

61
src/Artemis.UI/DataModelVisualization/DataModelViewModel.cs
View File

@ -1,54 +1,57 @@
using System;
using System.Linq;
using Artemis.Core.Attributes;
using Artemis.Core.Plugins.Abstract.DataModels;
using Artemis.UI.Exceptions;
using Artemis.Core.Plugins.Abstract.DataModels.Attributes;
using Humanizer;
using Stylet;
namespace Artemis.UI.DataModelVisualization
{
public class DataModelViewModel : PropertyChangedBase
public class DataModelViewModel : DataModelVisualizationViewModel
{
public DataModelViewModel(DataModel dataModel)
public DataModelViewModel()
{
if (!DataModel.Initialized)
throw new ArtemisUIException("Cannot create view model for data model that is not yet initialized");
DataModel = dataModel;
Children = new BindableCollection<DataModelVisualizationViewModel>();
}
public DataModelViewModel(DataModel parent, DataModel dataModel)
public DataModelViewModel(object model, DataModelPropertyAttribute propertyDescription, DataModelViewModel parent)
{
if (!DataModel.Initialized)
throw new ArtemisUIException("Cannot create view model for data model that is not yet initialized");
Model = model;
PropertyDescription = propertyDescription;
Parent = parent;
DataModel = dataModel;
Children = new BindableCollection<DataModelVisualizationViewModel>();
PopulateProperties();
}
public DataModel DataModel { get; }
public DataModel Parent { get; set; }
public object Model { get; }
public BindableCollection<DataModelVisualizationViewModel> Children { get; set; }
private void PopulateProperties()
public void PopulateProperties()
{
foreach (var propertyInfo in DataModel.GetType().GetProperties())
Children.Clear();
foreach (var propertyInfo in Model.GetType().GetProperties())
{
var dataModelPropertyAttribute = (DataModelPropertyAttribute) Attribute.GetCustomAttribute(propertyInfo, typeof(DataModelPropertyAttribute));
if (dataModelPropertyAttribute == null)
// Skip properties decorated with DataModelIgnore
if (Attribute.IsDefined(propertyInfo, typeof(DataModelIgnoreAttribute)))
continue;
// For child data models create another data model view model
if (typeof(DataModel).IsAssignableFrom(propertyInfo.PropertyType))
var dataModelPropertyAttribute = (DataModelPropertyAttribute) Attribute.GetCustomAttribute(propertyInfo, typeof(DataModelPropertyAttribute));
// If no DataModelProperty attribute was provided, pull one out of our ass
if (dataModelPropertyAttribute == null)
dataModelPropertyAttribute = new DataModelPropertyAttribute {Name = propertyInfo.Name.Humanize()};
// For value types create a child view model if the value type is not null
if (propertyInfo.PropertyType.IsValueType)
{
var value = propertyInfo.GetValue(Model);
if (value == null)
continue;
Children.Add(new DataModelViewModel(value, dataModelPropertyAttribute, this));
}
// For primitives, create a property view model
// For primitives, create a property view model, it may be null that is fine
else if (propertyInfo.PropertyType.IsPrimitive)
{
}
// For anything else check if it has any child primitives and if so create a property container view model
else if (propertyInfo.PropertyType.GetProperties().Any(p => p.PropertyType.IsPrimitive))
{
Children.Add(new DataModelPropertyViewModel(propertyInfo, dataModelPropertyAttribute, this));
}
}
}

30
src/Artemis.UI/Services/DataModelVisualizationService.cs Normal file
View File

@ -0,0 +1,30 @@
using Artemis.Core.Services.Interfaces;
using Artemis.UI.DataModelVisualization;
using Artemis.UI.Services.Interfaces;
namespace Artemis.UI.Services
{
public class DataModelVisualizationService : IDataModelVisualizationService
{
private readonly IDataModelService _dataModelService;
public DataModelVisualizationService(IDataModelService dataModelService)
{
_dataModelService = dataModelService;
}
public DataModelViewModel GetMainDataModelVisualization()
{
var viewModel = new DataModelViewModel();
foreach (var dataModelExpansion in _dataModelService.DataModelExpansions)
viewModel.Children.Add(new DataModelViewModel(dataModelExpansion, dataModelExpansion.DataModelDescription, viewModel));
return viewModel;
}
}
public interface IDataModelVisualizationService : IArtemisUIService
{
public DataModelViewModel GetMainDataModelVisualization();
}
}