public bool TryGet(IModelDefinition modelDefinition, IFieldDefinition fieldDefinition, out IFieldView <IRenderContext> fieldView)
{
fieldView = null;
if (modelDefinition.Identifier == nameof(Movie) && fieldDefinition.Identifier == nameof(Movie.RelatedMovieKeys))
{
fieldView = new ControlFieldView <RelatedMoviesFieldEditor>(fieldDefinition, new RelatedMoviesFieldEditor(new RelatedMoviesViewModel(navigator, library)));
}
else if (fieldDefinition.Identifier == "Country")
{
fieldView = new ComboBoxFieldEditor <string>(fieldDefinition, GetCountries());
}
else if (fieldDefinition.Identifier == "Category")
{
fieldView = new ComboBoxFieldEditor <string>(fieldDefinition, GetCategories());
}
else if (fieldDefinition.FieldType == typeof(DateTime))
{
fieldView = new DateFieldEditor(fieldDefinition);
}
else if (fieldDefinition.FieldType == typeof(string))
{
fieldView = new StringFieldEditor(fieldDefinition);
}
else if (fieldDefinition.FieldType == typeof(int) || fieldDefinition.FieldType == typeof(int?))
{
fieldView = new Int32FieldEditor(fieldDefinition);
}
return(fieldView != null);
}
/// <summary>
/// Creates new instance for models of type <paramref name="modelDefinition"/> from collection of <paramref name="elements"/>.
/// <paramref name="elements"/> are filtered by <paramref name="modelDefinition"/>.
/// </summary>
/// <param name="modelDefinition">Model definition.</param>
/// <param name="elements">Enumeration of elements to be used (at first, they are filtered by <paramref name="modelDefinition"/>).</param>
public XmlModelValueGetterCollection(IModelDefinition modelDefinition, IEnumerable <XElement> elements)
{
Ensure.NotNull(modelDefinition, "modelDefinition");
Ensure.NotNull(elements, "elements");
this.modelDefinition = modelDefinition;
this.elements = new List <XElement>(elements.Where(e => e.Name.LocalName == modelDefinition.Identifier));
}
/// <summary>
/// Provides logic for validating model.
/// </summary>
/// <param name="modelDefinition">Model definition.</param>
/// <param name="fieldDefinition">Defines field to validate.</param>
/// <param name="getter">Provides current values.</param>
/// <param name="resultBuilder">Validation result builder.</param>
protected virtual void ValidateInternal(IModelDefinition modelDefinition, IModelValueGetter getter, IValidationResultBuilder resultBuilder)
{
foreach (IFieldDefinition fieldDefinition in modelDefinition.Fields)
{
FieldValidator.Validate(modelDefinition, fieldDefinition, getter, resultBuilder);
}
}
public bool TryGet(IModelDefinition modelDefinition, IFieldDefinition fieldDefinition, out IFieldView <T> fieldView)
{
Ensure.NotNull(modelDefinition, "modelDefinition");
Ensure.NotNull(fieldDefinition, "fieldDefinition");
IFactory <IFieldView <T>, IFieldDefinition> modelViewActivator;
foreach (Key key in LazyEnumerateKeys(modelDefinition, fieldDefinition))
{
if (builders.TryGetValue(key, out modelViewActivator))
{
fieldView = modelViewActivator.Create(fieldDefinition);
return(true);
}
}
foreach (Key key in LazyEnumerateKeys(modelDefinition, fieldDefinition, true))
{
if (onSearchView.TryExecute(key, out modelViewActivator))
{
builders[key] = modelViewActivator;
fieldView = modelViewActivator.Create(fieldDefinition);
return(true);
}
}
fieldView = null;
return(false);
}
private IEnumerable <Key> LazyEnumerateKeys(IModelDefinition modelDefinition, IFieldDefinition fieldDefinition, bool isForSearchHandler = false)
{
string modelIdentifier = modelDefinition.Identifier;
string fieldIdentifier = fieldDefinition.Identifier;
Type fieldType = fieldDefinition.FieldType;
string uiHint;
if (!fieldDefinition.Metadata.TryGet("UiHint", out uiHint))
{
uiHint = null;
}
if (isForSearchHandler)
{
yield return(new Key(modelIdentifier, fieldIdentifier, uiHint, fieldType));
}
else
{
yield return(new Key(modelIdentifier, fieldIdentifier, null, fieldType));
yield return(new Key(modelIdentifier, null, uiHint, fieldType));
yield return(new Key(null, null, uiHint, fieldType));
yield return(new Key(null, null, null, fieldType));
}
}
/// <summary>
/// Creates new instance. Parameters can't be <c>null</c>.
/// </summary>
/// <param name="definition">Model definition.</param>
/// <param name="getter">Model values to validate.</param>
public ModelValidatorContext(IModelDefinition definition, IModelValueGetter getter)
{
Ensure.NotNull(definition, "definition");
Ensure.NotNull(getter, "getter");
Definition = definition;
Getter = getter;
}
/// <summary>
/// Tries to get model definition for identifier <paramref name="modelIdentifier"/>.
/// </summary>
/// <param name="modelIdentifier">Identifier of requested model definition.</param>
/// <param name="modelDefinition">Model definition.</param>
/// <returns><c>true</c> if model was found; <c>false</c> otherwise.</returns>
public bool TryGet(string modelIdentifier, out IModelDefinition modelDefinition)
{
Ensure.NotNullOrEmpty(modelIdentifier, "modelIdentifier");
// Search in singletons.
if (singletons.TryGetValue(modelIdentifier, out modelDefinition))
{
return(true);
}
lock (storageLock)
{
// Search in builders.
IFactory <IModelDefinition> builder;
if (builders.TryGetValue(modelIdentifier, out builder))
{
singletons[modelIdentifier] = modelDefinition = builder.Create();
return(true);
}
// Search using search handlers.
if (onSearchDefinition.TryExecute(modelIdentifier, out modelDefinition))
{
singletons[modelIdentifier] = modelDefinition;
return(true);
}
}
// Unnable to find model definition.
modelDefinition = null;
return(true);
}
public ModelDefinition(IModelDefinition copyFrom) : base(copyFrom)
{
if (copyFrom != null && copyFrom.Properties.Any())
{
Properties.AddRange(copyFrom.Properties.Select(x => new ModelPropertyDefinition(x)));
}
}
private void LoadFields(XElement element, IModelDefinition modelDefinition, IModelValueSetter setter)
{
foreach (IFieldDefinition fieldDefinition in modelDefinition.Fields)
{
if (fieldDefinition.Metadata.Get("IsPersistent", true))
{
string rawValue = null;
if (fieldDefinition.Metadata.Get("IsXmlElementContent", false))
{
rawValue = element.Value;
}
else
{
rawValue = element.Attribute(fieldDefinition.Identifier)?.Value;
}
if (rawValue != null)
{
rawValue = rawValue.Trim();
if (converters.TryConvert(typeof(string), fieldDefinition.FieldType, rawValue, out object value))
{
setter.TrySetValue(fieldDefinition.Identifier, value);
}
}
}
}
}
private void SaveFields(XElement element, IModelDefinition modelDefinition, IModelValueGetter getter)
{
foreach (IFieldDefinition fieldDefinition in modelDefinition.Fields)
{
if (fieldDefinition.Metadata.Get("IsPersistent", true))
{
if (getter.TryGetValue(fieldDefinition.Identifier, out object value))
{
if (value != null && converters.TryConvert(value.GetType(), typeof(string), value, out object stringValue))
{
if (fieldDefinition.Metadata.Get("IsXmlElementContent", false))
{
string raw = (string)stringValue;
if (!String.IsNullOrEmpty(raw) && !String.IsNullOrWhiteSpace(raw))
{
element.Value = (string)stringValue;
}
}
else
{
element.SetAttributeValue(fieldDefinition.Identifier, (string)stringValue);
}
}
}
}
}
}
public void GetValues()
{
IModelDefinition modelDefinition = modelDefinitions.Get <RegisterUserModel>();
RegisterUserModel model = new RegisterUserModel();
model.Username = "******";
model.Password = "******";
model.PasswordAgain = "y";
IModelValueProvider reflection = new ReflectionModelValueProvider(model, valueUpdaters);
DictionaryModelValueProvider dictionary = new DictionaryModelValueProvider();
CopyModelValueProvider copyProvider = new CopyModelValueProvider(modelDefinition, true);
copyProvider.Update(dictionary, reflection);
object value;
Assert.IsTrue(dictionary.TryGetValue(nameof(RegisterUserModel.Username), out value));
Assert.AreEqual(model.Username, value);
Assert.IsTrue(dictionary.TryGetValue(nameof(RegisterUserModel.Password), out value));
Assert.AreEqual(model.Password, value);
Assert.IsTrue(dictionary.TryGetValue(nameof(RegisterUserModel.PasswordAgain), out value));
Assert.AreEqual(model.PasswordAgain, value);
}
public GridModelView(IModelDefinition modelDefinition, IFieldViewProvider <IRenderContext> fieldViewProvider)
: base(modelDefinition)
{
Ensure.NotNull(modelDefinition, "modelDefinition");
Ensure.NotNull(fieldViewProvider, "fieldViewProvider");
this.modelDefinition = modelDefinition;
this.fieldViewProvider = fieldViewProvider;
}
public ModelDefinition(IModelDefinition copyFrom)
: base(copyFrom)
{
if (copyFrom != null && copyFrom.Properties.Any())
{
Properties.AddRange(copyFrom.Properties.Select(x => new ModelPropertyDefinition(x)));
}
}
/// <summary>
/// Creates new instance for <paramref name="modelDefinition"/> and target to <paramref name="element"/>.
/// </summary>
/// <param name="modelDefinition">Model definition.</param>
/// <param name="element">Value target element.</param>
public XmlModelValueSetter(IModelDefinition modelDefinition, XElement element)
{
Ensure.NotNull(modelDefinition, "modelDefinition");
Ensure.NotNull(element, "element");
this.modelDefinition = modelDefinition;
this.fieldDefinitions = modelDefinition.FieldsByIdentifier();
this.element = element;
}
public void UpdateModel(IModelDefinition definition, IModelValueProvider model, IModelValueGetter newState)
{
CopyModelValueProvider copy = new CopyModelValueProvider(definition, true);
copy.Update(model, newState);
Has = true;
Added?.Invoke();
}
/// <summary>
/// Create a new instance.
/// </summary>
/// <param name="definition">A model definition of the item.</param>
/// <param name="getter">A value getter of the time.</param>
/// <param name="metadata">A collection of metadata from an envelope</param>
public ObjectVisualization(IModelDefinition definition, IModelValueGetter getter, IReadOnlyKeyValueCollection metadata)
{
Ensure.NotNull(definition, "definition");
Ensure.NotNull(getter, "getter");
Ensure.NotNull(metadata, "metadata");
Definition = definition;
Getter = getter;
Metadata = metadata;
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="key">A key of the aggregate root.</param>
/// <param name="definition">A model definition of the aggregate root.</param>
/// <param name="events">A list of the events visualization applied to the aggregate root.</param>
public AggregateRootVisualization(IKey key, IModelDefinition definition, IReadOnlyList <ObjectVisualization> events)
{
Ensure.Condition.NotEmptyKey(key);
Ensure.NotNull(definition, "definition");
Ensure.NotNull(events, "events");
Key = key;
Definition = definition;
Events = events;
}
public BindingModelValueGetter(IBindingModelValueStorage storage, IBindingConverterProvider converterCollection, IModelDefinition modelDefinition)
{
Ensure.NotNull(storage, "storage");
Ensure.NotNull(converterCollection, "converterCollection");
Ensure.NotNull(modelDefinition, "modelDefinition");
Storage = storage;
ConverterCollection = converterCollection;
ModelDefinition = modelDefinition;
}
/// <summary>
/// Registers instance of model definition.
/// </summary>
/// <param name="modelDefinition">Model definition to register.</param>
/// <returns>Self (for fluency).</returns>
public ModelDefinitionCollection Add(IModelDefinition modelDefinition)
{
Ensure.NotNull(modelDefinition, "modelDefinition");
lock (storageLock)
{
singletons[modelDefinition.Identifier] = modelDefinition;
}
return(this);
}
public ModelValueCollection(ReflectionModelValueProvider <ISettings> valueProvider, IModelDefinition modelDefinition, IConverterRepository converters)
{
Ensure.NotNull(valueProvider, "valueProvider");
Ensure.NotNull(modelDefinition, "modelDefinition");
Ensure.NotNull(converters, "converters");
this.modelDefinition = modelDefinition;
this.converters = converters;
ValueProvider = valueProvider;
Keys = modelDefinition.Fields.Select(f => f.Identifier);
}
public void Validate(IModelDefinition modelDefinition, IFieldDefinition fieldDefinition, IModelValueGetter getter, IValidationResultBuilder resultBuilder)
{
foreach (string key in fieldDefinition.Metadata.Keys)
{
IFieldMetadataValidator validator;
if (Validators.TryGet(modelDefinition.Identifier, fieldDefinition.Identifier, key, out validator))
{
validator.Validate(fieldDefinition, getter, resultBuilder);
}
}
}
/// <summary>
/// Registers instance of model definition to be mapped to <paramref name="modelType" />.
/// </summary>
/// <param name="modelType">Type to register model definition to.</param>
/// <param name="modelDefinition">Model definition to register.</param>
/// <returns>Self (for fluency).</returns>
public TypeModelDefinitionCollection Add(Type modelType, IModelDefinition modelDefinition)
{
Ensure.NotNull(modelType, "modelType");
Ensure.NotNull(modelDefinition, "modelDefinition");
lock (storageLock)
{
singletons[modelType] = modelDefinition;
}
return(this);
}
/// <summary>
/// Returns field view for field and model definition.
/// If such view is not registered, <see cref="InvalidOperationException"/> is thrown.
/// </summary>
/// <param name="provider">View provider.</param>
/// <param name="modelDefinition">Model definition that contains <paramref name="fieldDefinition" /></param>
/// <param name="fieldDefinition">Field definition to find field view for.</param>
/// <returns>Instance of registered field view.</returns>
/// <exception cref="InvalidOperationException">When <paramref name="provider"/> can provide field view.</exception>
public static IFieldView <T> Get <T>(this IFieldViewProvider <T> provider, IModelDefinition modelDefinition, IFieldDefinition fieldDefinition)
{
Ensure.NotNull(provider, "provider");
IFieldView <T> fieldView;
if (provider.TryGet(modelDefinition, fieldDefinition, out fieldView))
{
return(fieldView);
}
throw Ensure.Exception.InvalidOperation("Provider doesn't contain field view for model '{0}' and field '{1}'.", modelDefinition.Identifier, fieldDefinition.Identifier);
}
public SimpleMLModel(IModelDefinition model, bool init = false)
{
this.Model = model;
if (init)
{
// Initial ML Model Definition
this.Init();
// Load CSV Data
this.LoadDataFromCsv(csvFilePath: Resources.ResourceManager.GetString("modelDataFilePath"), hasHeader: true);
}
}
/// <summary>
/// Returns fields from <paramref name="modelDefinition"/> mapped to dictionary by <see cref="IFieldDefinition.Identifier"/>.
/// </summary>
/// <param name="modelDefinition">Source model definition to read fields from.</param>
/// <returns>Fields from <paramref name="modelDefinition"/> mapped to dictionary by <see cref="IFieldDefinition.Identifier"/>.</returns>
public static Dictionary <string, IFieldDefinition> FieldsByIdentifier(this IModelDefinition modelDefinition)
{
Ensure.NotNull(modelDefinition, "modelDefinition");
Dictionary <string, IFieldDefinition> result = new Dictionary <string, IFieldDefinition>();
foreach (IFieldDefinition fieldDefinition in modelDefinition.Fields)
{
result[fieldDefinition.Identifier] = fieldDefinition;
}
return(result);
}
/// <summary>
/// Returns model view for model definition.
/// If such view is not registered, <see cref="InvalidOperationException"/> is thrown.
/// </summary>
/// <param name="provider">View provider.</param>
/// <param name="modelDefinition">Model definition.</param>
/// <returns>Instance of registered model view.</returns>
/// <exception cref="InvalidOperationException">When <paramref name="provider"/> can provide model view.</exception>
public static IModelView <T> Get <T>(this IModelViewProvider <T> provider, IModelDefinition modelDefinition)
{
Ensure.NotNull(provider, "provider");
IModelView <T> modelView;
if (provider.TryGet(modelDefinition, out modelView))
{
return(modelView);
}
throw Ensure.Exception.InvalidOperation("Provider doesn't contain model view for model '{0}'.", modelDefinition.Identifier);
}
private XDocument SerializeModelDefinition(IModelDefinition modelDefinition)
{
XElement result = new XElement(XName.Get(XmlNameDefinition.ModelDefinitionElementName, XmlNameDefinition.XmlnsUri));
result.Add(new XAttribute(XmlNameDefinition.ModelDefinitionIdentifierAttributeName, modelDefinition.Identifier));
result.Add(SerializeMetadata(modelDefinition.Metadata));
result.Add(modelDefinition.Fields.Select(SerializeFieldDefinition));
XDocument document = new XDocument(new XDeclaration("1.0", "UTF-8", "yes"), result);
return(document);
}
public bool TryGet(IModelDefinition modelDefinition, out IModelView <IRenderContext> modelView)
{
if (modelDefinition.Identifier == "Movie")
{
modelView = new GridModelView(modelDefinition, this);
}
else
{
modelView = new StackPanelModelView(modelDefinition, this);
}
return(true);
}
public MovieEditWindow(INavigator navigator, IChangeTracker changeTracker, Library library, Movie model)
: base(navigator, library)
{
Ensure.NotNull(changeTracker, "changeTracker");
Ensure.NotNull(library, "library");
InitializeComponent();
kebClose.Command = new DelegateCommand(Close);
this.changeTracker = changeTracker;
this.library = library;
this.modelDefinition = library.MovieDefinition;
this.model = model;
}
private static void SetContainerDefinition(DependencyObject d, IModelDefinition modelDefinition)
{
FieldDefinitionContainer container = GetContainer(d);
string identifier = GetIdentifier(d);
if (container != null)
{
if (identifier != null && modelDefinition != null)
{
container.Definition = modelDefinition.Fields.FirstOrDefault(f => f.Identifier == identifier);
}
else
{
container.Definition = null;
}
}
}
public LibraryConfigurationWindow(INavigator navigator, IChangeTracker changeTracker, Library library)
: base(navigator, library)
{
Ensure.NotNull(changeTracker, "changeTracker");
Ensure.NotNull(library, "library");
UserModelPresenter.SetContainer(this, new ModelDefinitionContainer());
UserModelPresenter.SetValueProviderCollection(this, new FieldValueProviderCollection());
InitializeComponent();
kebClose.Command = new DelegateCommand(Close);
this.changeTracker = changeTracker;
this.library = library;
this.modelDefinition = library.ConfigurationDefinition;
}
/// <summary>
/// Adds the model to the repository.
/// </summary>
/// <param name="type">The instance type to which the definition applies.</param>
/// <param name="modelDefinition">The model definition.</param>
public void AddModel(Type type, IModelDefinition modelDefinition)
{
_definitions[type] = modelDefinition;
}
public static void DefaultSwaseyModelWriter(string name, string content, IModelDefinition definition)
{
throw new NotImplementedException();
}
public void Write(string name, string content, IModelDefinition definition)
{
Builder.Append(content);
}
