internal void ValidateConditionsTypeIsNotEmpty(ValidationContext context, MenuSettings settings)
{
Guard.NotNull(() => context, context);
Guard.NotNull(() => settings, settings);
try
{
foreach (var condition in settings.ConditionSettings.Where(s => string.IsNullOrEmpty(s.TypeId)))
{
context.LogError(
string.Format(CultureInfo.CurrentCulture, Resources.Validate_ConditionSettingsTypeIsNotEmpty, settings.Name),
Resources.Validate_ConditionSettingsTypeIsNotEmptyCode,
settings);
}
// TODO: validate value providers for the condition bindings too:
// var conditionBindings = this.Settings.ConditionSettings.Select(x => this.BindingFactory.Create<ICondition>(x)).ToArray();
// then like in the CommandSettings.Validation.cs
}
catch (Exception ex)
{
tracer.Error(
ex,
Resources.ValidationMethodFailed_Error,
Reflector <MenuSettingsValidations> .GetMethod(n => n.ValidateConditionsTypeIsNotEmpty(null, null)).Name);
throw;
}
}
internal void ValidateWizardIdIsValid(ValidationContext context, MenuSettings settings)
{
Guard.NotNull(() => context, context);
Guard.NotNull(() => settings, settings);
try
{
if (settings.WizardId != Guid.Empty)
{
if (!settings.Owner.GetAutomationSettings <IWizardSettings>().Any(c => c.Id.Equals(settings.WizardId)))
{
if (settings.Owner.IsInheritedFromBase &&
SettingsValidationHelper.TryToFixId <IWizardSettings>(settings.Store, settings.Owner, settings.WizardId, id => settings.WizardId = id))
{
return;
}
context.LogError(
string.Format(
CultureInfo.CurrentCulture,
Resources.Validate_WizardIsNotValid),
Resources.Validate_WizardIsNotValidCode, settings.Extends);
}
}
}
catch (Exception ex)
{
tracer.Error(
ex,
Properties.Resources.ValidationMethodFailed_Error,
Reflector <MenuSettingsValidations> .GetMethod(n => n.ValidateWizardIdIsValid(null, null)).Name);
throw;
}
}
internal void ValidateTextIsNotEmpty(ValidationContext context, MenuSettings settings)
{
Guard.NotNull(() => context, context);
Guard.NotNull(() => settings, settings);
try
{
// Ensure not empty
if (string.IsNullOrEmpty(settings.Text))
{
context.LogError(
string.Format(CultureInfo.CurrentCulture, Resources.Validate_MenuSettingsMenuTextIsNotEmpty, settings.Name),
Resources.Validate_MenuSettingsMenuTextIsNotEmptyCode,
settings.Extends);
}
// TODO: Ensure it still exists
}
catch (Exception ex)
{
tracer.Error(
ex,
Resources.ValidationMethodFailed_Error,
Reflector <MenuSettingsValidations> .GetMethod(n => n.ValidateTextIsNotEmpty(null, null)).Name);
throw;
}
}
internal void ValidateCommandIdAndWizardIdIsNotEmpty(ValidationContext context, MenuSettings settings)
{
Guard.NotNull(() => context, context);
Guard.NotNull(() => settings, settings);
try
{
// Ensure not empty
if (settings.CommandId == Guid.Empty && settings.WizardId == Guid.Empty)
{
context.LogError(
string.Format(
CultureInfo.CurrentCulture,
Resources.Validate_MenuSettingsCommandIdAndWizardIdIsNotEmpty,
settings.Name),
Resources.Validate_MenuSettingsCommandIdAndWizardIdIsNotEmptyCode, settings.Extends);
}
}
catch (Exception ex)
{
tracer.Error(
ex,
Resources.ValidationMethodFailed_Error,
Reflector<MenuSettingsValidations>.GetMethod(n => n.ValidateCommandIdAndWizardIdIsNotEmpty(null, null)).Name);
throw;
}
}
public void InitializeContext()
{
this.store.TransactionManager.DoWithinTransaction(() =>
{
var patternModel = this.store.ElementFactory.CreateElement<PatternModelSchema>();
var pattern = patternModel.Create<PatternSchema>();
var automationSettings = pattern.Create<AutomationSettingsSchema>();
this.settings = automationSettings.AddExtension<MenuSettings>();
});
this.validator = new MenuSettingsValidations(Mock.Of<INuPatternCompositionService>())
{
ProjectTypeProvider = Mock.Of<INuPatternProjectTypeProvider>(),
};
validationContext = new ValidationContext(ValidationCategories.Save, this.settings);
}
internal void ValidateIconIsEmptyOrValid(ValidationContext context, MenuSettings settings)
{
Guard.NotNull(() => context, context);
Guard.NotNull(() => settings, settings);
try
{
if (!string.IsNullOrEmpty(settings.Icon))
{
var uriService = ((IServiceProvider)settings.Store).GetService <IUriReferenceService>();
var resolvedIcon = uriService.ResolveUri <ResourcePack>(new Uri(settings.Icon));
if (resolvedIcon == null)
{
context.LogError(
string.Format(CultureInfo.CurrentCulture, Resources.Validate_MenuSettingsIconDoesNotPointToAValidFile, settings.Name),
Resources.Validate_MenuSettingsIconDoesNotPointToAValidFileCode,
settings);
return;
}
if (resolvedIcon.Type == ResourcePackType.ProjectItem)
{
var item = resolvedIcon.GetItem();
if (item.Data.ItemType != @"Resource")
{
context.LogError(
string.Format(CultureInfo.CurrentCulture, Resources.Validate_MenuSettingsIconIsNotAResource, settings.Name, item.Name),
Resources.Validate_MenuSettingsIconIsNotAResourceCode,
settings);
}
}
}
}
catch (Exception ex)
{
tracer.Error(
ex,
Resources.ValidationMethodFailed_Error,
Reflector <MenuSettingsValidations> .GetMethod(n => n.ValidateIconIsEmptyOrValid(null, null)).Name);
throw;
}
}
private static void WritePropertiesAsElements(DslModeling::SerializationContext serializationContext, MenuSettings element, global::System.Xml.XmlWriter writer)
{
// Conditions
if (!serializationContext.Result.Failed)
{
global::System.String propValue = element.Conditions;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
LibrarySerializationHelper.Instance.WriteElementString(serializationContext, element, writer, "conditions", propValue);
}
}
}
private static void ReadPropertiesFromElements(DslModeling::SerializationContext serializationContext, MenuSettings element, global::System.Xml.XmlReader reader)
{
while (!serializationContext.Result.Failed && !reader.EOF && reader.NodeType == global::System.Xml.XmlNodeType.Element)
{
switch (reader.LocalName)
{
case "conditions": // Conditions
if (reader.IsEmptyElement)
{ // No serialized value, must be default one.
DslModeling::SerializationUtilities.Skip(reader); // Skip this tag.
}
else
{
string strConditions = LibrarySerializationHelper.Instance.ReadElementContentAsString(serializationContext, element, reader);
global::System.String valueOfConditions;
if (DslModeling::SerializationUtilities.TryGetValue<global::System.String>(serializationContext, strConditions, out valueOfConditions))
{
element.Conditions = valueOfConditions;
}
else
{ // Invalid property value, ignored.
LibrarySerializationBehaviorSerializationMessages.IgnoredPropertyValue(serializationContext, reader, "conditions", typeof(global::System.String), strConditions);
}
DslModeling::SerializationUtilities.SkipToNextElement(reader);
}
break;
default:
return; // Don't know this element.
}
}
}
internal void ValidateCommandIdAndWizardIdIsNotEmpty(ValidationContext context, MenuSettings settings)
{
Guard.NotNull(() => context, context);
Guard.NotNull(() => settings, settings);
try
{
// Ensure not empty
if (settings.CommandId == Guid.Empty && settings.WizardId == Guid.Empty)
{
context.LogError(
string.Format(
CultureInfo.CurrentCulture,
Resources.Validate_MenuSettingsCommandIdAndWizardIdIsNotEmpty,
settings.Name),
Resources.Validate_MenuSettingsCommandIdAndWizardIdIsNotEmptyCode, settings.Extends);
}
}
catch (Exception ex)
{
tracer.Error(
ex,
Resources.ValidationMethodFailed_Error,
Reflector <MenuSettingsValidations> .GetMethod(n => n.ValidateCommandIdAndWizardIdIsNotEmpty(null, null)).Name);
throw;
}
}
internal void ValidateCanResolveNonEmptyConditionsType(ValidationContext context, MenuSettings settings)
{
Guard.NotNull(() => context, context);
Guard.NotNull(() => settings, settings);
try
{
var conditions = settings.ConditionSettings;
foreach (var condition in conditions.Where(s =>
!string.IsNullOrEmpty(s.TypeId) &&
s.FindBoundType <ICondition>(Conditions, context) == null))
{
context.LogWarning(string.Format(
CultureInfo.CurrentCulture,
Resources.Validate_CannotResolveType,
condition.TypeId,
settings.Name),
Resources.Validate_CannotResolveTypeCode,
settings.Extends);
}
// TODO: validate value providers for the condition bindings too:
// var conditionBindings = this.Settings.ConditionSettings.Select(x => this.BindingFactory.Create<ICondition>(x)).ToArray();
// then like in the CommandSettings.Validation.cs
}
catch (Exception ex)
{
tracer.Error(
ex,
Properties.Resources.ValidationMethodFailed_Error,
Reflector <MenuSettingsValidations> .GetMethod(n => n.ValidateCanResolveNonEmptyConditionsType(null, null)).Name);
throw;
}
}
internal void ValidateIconIsEmptyOrValid(ValidationContext context, MenuSettings settings)
{
Guard.NotNull(() => context, context);
Guard.NotNull(() => settings, settings);
try
{
if (!string.IsNullOrEmpty(settings.Icon))
{
var uriService = ((IServiceProvider)settings.Store).GetService<IUriReferenceService>();
var resolvedIcon = uriService.ResolveUri<ResourcePack>(new Uri(settings.Icon));
if (resolvedIcon == null)
{
context.LogError(
string.Format(CultureInfo.CurrentCulture, Resources.Validate_MenuSettingsIconDoesNotPointToAValidFile, settings.Name),
Resources.Validate_MenuSettingsIconDoesNotPointToAValidFileCode,
settings);
return;
}
if (resolvedIcon.Type == ResourcePackType.ProjectItem)
{
var item = resolvedIcon.GetItem();
if (item.Data.ItemType != @"Resource")
{
context.LogError(
string.Format(CultureInfo.CurrentCulture, Resources.Validate_MenuSettingsIconIsNotAResource, settings.Name, item.Name),
Resources.Validate_MenuSettingsIconIsNotAResourceCode,
settings);
}
}
}
}
catch (Exception ex)
{
tracer.Error(
ex,
Resources.ValidationMethodFailed_Error,
Reflector<MenuSettingsValidations>.GetMethod(n => n.ValidateIconIsEmptyOrValid(null, null)).Name);
throw;
}
}
internal void ValidateCanResolveNonEmptyConditionsType(ValidationContext context, MenuSettings settings)
{
Guard.NotNull(() => context, context);
Guard.NotNull(() => settings, settings);
try
{
var conditions = settings.ConditionSettings;
foreach (var condition in conditions.Where(s =>
!string.IsNullOrEmpty(s.TypeId) &&
s.FindBoundType<ICondition>(Conditions, context) == null))
{
context.LogWarning(string.Format(
CultureInfo.CurrentCulture,
Resources.Validate_CannotResolveType,
condition.TypeId,
settings.Name),
Resources.Validate_CannotResolveTypeCode,
settings.Extends);
}
// TODO: validate value providers for the condition bindings too:
// var conditionBindings = this.Settings.ConditionSettings.Select(x => this.BindingFactory.Create<ICondition>(x)).ToArray();
// then like in the CommandSettings.Validation.cs
}
catch (Exception ex)
{
tracer.Error(
ex,
Properties.Resources.ValidationMethodFailed_Error,
Reflector<MenuSettingsValidations>.GetMethod(n => n.ValidateCanResolveNonEmptyConditionsType(null, null)).Name);
throw;
}
}
internal void ValidateConditionsTypeIsNotEmpty(ValidationContext context, MenuSettings settings)
{
Guard.NotNull(() => context, context);
Guard.NotNull(() => settings, settings);
try
{
foreach (var condition in settings.ConditionSettings.Where(s => string.IsNullOrEmpty(s.TypeId)))
{
context.LogError(
string.Format(CultureInfo.CurrentCulture, Resources.Validate_ConditionSettingsTypeIsNotEmpty, settings.Name),
Resources.Validate_ConditionSettingsTypeIsNotEmptyCode,
settings);
}
// TODO: validate value providers for the condition bindings too:
// var conditionBindings = this.Settings.ConditionSettings.Select(x => this.BindingFactory.Create<ICondition>(x)).ToArray();
// then like in the CommandSettings.Validation.cs
}
catch (Exception ex)
{
tracer.Error(
ex,
Resources.ValidationMethodFailed_Error,
Reflector<MenuSettingsValidations>.GetMethod(n => n.ValidateConditionsTypeIsNotEmpty(null, null)).Name);
throw;
}
}
internal void ValidateTextIsNotEmpty(ValidationContext context, MenuSettings settings)
{
Guard.NotNull(() => context, context);
Guard.NotNull(() => settings, settings);
try
{
// Ensure not empty
if (string.IsNullOrEmpty(settings.Text))
{
context.LogError(
string.Format(CultureInfo.CurrentCulture, Resources.Validate_MenuSettingsMenuTextIsNotEmpty, settings.Name),
Resources.Validate_MenuSettingsMenuTextIsNotEmptyCode,
settings.Extends);
}
// TODO: Ensure it still exists
}
catch (Exception ex)
{
tracer.Error(
ex,
Resources.ValidationMethodFailed_Error,
Reflector<MenuSettingsValidations>.GetMethod(n => n.ValidateTextIsNotEmpty(null, null)).Name);
throw;
}
}
internal void ValidateWizardIdIsValid(ValidationContext context, MenuSettings settings)
{
Guard.NotNull(() => context, context);
Guard.NotNull(() => settings, settings);
try
{
if (settings.WizardId != Guid.Empty)
{
if (!settings.Owner.GetAutomationSettings<IWizardSettings>().Any(c => c.Id.Equals(settings.WizardId)))
{
if (settings.Owner.IsInheritedFromBase &&
SettingsValidationHelper.TryToFixId<IWizardSettings>(settings.Store, settings.Owner, settings.WizardId, id => settings.WizardId = id))
{
return;
}
context.LogError(
string.Format(
CultureInfo.CurrentCulture,
Resources.Validate_WizardIsNotValid),
Resources.Validate_WizardIsNotValidCode, settings.Extends);
}
}
}
catch (Exception ex)
{
tracer.Error(
ex,
Properties.Resources.ValidationMethodFailed_Error,
Reflector<MenuSettingsValidations>.GetMethod(n => n.ValidateWizardIdIsValid(null, null)).Name);
throw;
}
}