/// <summary>
/// Set the values of a ReqIF enum (single value or multi value) in the ReqIF (AttributeDefinition)
/// </summary>
/// <param name="attributeValueEnumeration"></param>
/// <param name="value"></param>
public bool SetReqIfEnumValue(AttributeValueEnumeration attributeValueEnumeration, string value, EA.Element el = null)
{
if (attributeValueEnumeration.Definition == null)
{
return(true);
}
// delete old values
attributeValueEnumeration.Values.Clear();
if (!attributeValueEnumeration.Definition.IsMultiValued)
{
// single value enum
// Check if valid value
if (String.IsNullOrWhiteSpace(value))
{
MessageBox.Show($@"Empty value of ReqIF Attribute: '{attributeValueEnumeration.Definition.LongName}'
Req: '{el?.Name}'
ReqGuid: '{el?.ElementGUID}'
", @"Can't find enum value, break");
return(false);
}
var enumValue = attributeValueEnumeration.Definition.Type.SpecifiedValues
.SingleOrDefault(x => x.LongName == value.Trim());
if (enumValue == null)
{
MessageBox.Show($@"ReqIF Attribute: '{attributeValueEnumeration.Definition.LongName}'
Value='{value}'
", @"Can't find enum value, break");
return(false);
}
attributeValueEnumeration.Values.Add(enumValue);
}
else
{ // all enums (multi value enum)
// no value is valid
if (String.IsNullOrWhiteSpace(value))
{
return(true);
}
var enumValues = attributeValueEnumeration.Definition.Type.SpecifiedValues
.Select(x => x);
var values = Regex.Replace(value.Trim(), @"\r\n?|\n|;|,|:|-|=", ",").Split(',');
int index = 0;
foreach (EnumValue enumValue in enumValues)
{
if (values.Length > index && values[index] == "1")
{
attributeValueEnumeration.Values.Add(enumValue);
}
index += 1;
}
}
return(true);
}
public void Verify_That_Exception_Is_Raised_When_Invalid_AttributeDefinition_Is_Set()
{
var attributeDefinitionString = new AttributeDefinitionString();
var attributeValueEnumeration = new AttributeValueEnumeration();
var attributeValue = (AttributeValue)attributeValueEnumeration;
Assert.Throws <ArgumentException>(() => attributeValue.AttributeDefinition = attributeDefinitionString);
}
public void VerifytThatExceptionIsRaisedWhenInvalidAttributeDefinitionIsSet()
{
var attributeDefinitionString = new AttributeDefinitionString();
var attributeValueEnumeration = new AttributeValueEnumeration();
var attributeValue = (AttributeValue)attributeValueEnumeration;
Assert.Throws <ArgumentException>(() => attributeValue.AttributeDefinition = attributeDefinitionString);
}
public void Verify_That_WriteXml_Without_Definition_Set_Throws_SerializationException()
{
using var memoryStream = new MemoryStream();
using var writer = XmlWriter.Create(memoryStream, new XmlWriterSettings { Indent = true });
var attributeValueEnumeration = new AttributeValueEnumeration();
Assert.That(() => attributeValueEnumeration.WriteXml(writer),
Throws.Exception.TypeOf <SerializationException>());
}
public void Verify_that_when_ObjectValue_is_not_real_an_exception_is_thrown()
{
var attributeValue = new AttributeValueEnumeration();
Assert.That(
() => attributeValue.ObjectValue = "true",
Throws.Exception.TypeOf <InvalidOperationException>()
.With.Message.Contains("The value to set is not an IEnumerable<EnumValue>."));
}
public void Verify_That_WriteXmlAsync_Without_Definition_Set_Throws_SerializationException()
{
using var memoryStream = new MemoryStream();
using var writer = XmlWriter.Create(memoryStream, new XmlWriterSettings { Indent = true });
var attributeValueEnumeration = new AttributeValueEnumeration();
var cts = new CancellationTokenSource();
Assert.That(async() => await attributeValueEnumeration.WriteXmlAsync(writer, cts.Token),
Throws.Exception.TypeOf <SerializationException>());
}
public void VerifyConvenienceValueProperty()
{
var attributeValue = new AttributeValueEnumeration();
var val = new List <EnumValue> {
new EnumValue()
};
attributeValue.ObjectValue = val;
Assert.AreEqual(attributeValue.Values.Count, 1);
}
public void Verify_Convenience_Value_Property()
{
var attributeValue = new AttributeValueEnumeration();
var val = new List <EnumValue> {
new EnumValue()
};
attributeValue.ObjectValue = val;
Assert.That(attributeValue.Values.Count, Is.EqualTo(1));
}
public void VerifyThatWriteXmlWithoutDefinitionSetThrowsSerializationException()
{
using (var fs = new FileStream("test.xml", FileMode.Create))
{
using (var writer = XmlWriter.Create(fs, new XmlWriterSettings {
Indent = true
}))
{
var attributeValueEnumeration = new AttributeValueEnumeration();
Assert.Throws <SerializationException>(() => attributeValueEnumeration.WriteXml(writer));
}
}
}
private void AddAttributeButton_Click(object sender, RoutedEventArgs e)
{
var dataGridRowIndex = ((sender as Button).BindingGroup.Owner as DataGridRow).GetIndex();
AttributeDefinition selectedAttribute = _attributes[dataGridRowIndex].AttributeDefinition;
AttributeValue attributeValue = null;
if (selectedAttribute.GetType() == typeof(AttributeDefinitionBoolean))
{
attributeValue = new AttributeValueBoolean();
attributeValue.ObjectValue = false;
}
else if (selectedAttribute.GetType() == typeof(AttributeDefinitionDate))
{
attributeValue = new AttributeValueDate();
attributeValue.ObjectValue = DateTime.Now;
}
else if (selectedAttribute.GetType() == typeof(AttributeDefinitionEnumeration))
{
attributeValue = new AttributeValueEnumeration();
List <EnumValue> enumValues = new List <EnumValue>();
enumValues.Add(((DatatypeDefinitionEnumeration)selectedAttribute.DatatypeDefinition).SpecifiedValues.First());
attributeValue.ObjectValue = enumValues;
}
else if (selectedAttribute.GetType() == typeof(AttributeDefinitionInteger))
{
attributeValue = new AttributeValueInteger();
attributeValue.ObjectValue = "";
}
else if (selectedAttribute.GetType() == typeof(AttributeDefinitionReal))
{
attributeValue = new AttributeValueReal();
attributeValue.ObjectValue = "";
}
else if (selectedAttribute.GetType() == typeof(AttributeDefinitionString))
{
attributeValue = new AttributeValueString();
attributeValue.ObjectValue = "";
}
else if (selectedAttribute.GetType() == typeof(AttributeDefinitionXHTML))
{
attributeValue = new AttributeValueXHTML();
attributeValue.ObjectValue = "<div></div>";
}
attributeValue.AttributeDefinition = selectedAttribute;
attributeValue.SpecElAt = (Application.Current.MainWindow as MainWindow).content.SpecObjects.SingleOrDefault(x => x.Identifier == _specObject.Identifier);
_attributes[dataGridRowIndex].AttributeValue = attributeValue;
_attributes[dataGridRowIndex].added = true;
}
public void Verify_That_The_AttributeDefinition_Can_Be_Set_Or_Get()
{
var attributeDefinitionEnumeration = new AttributeDefinitionEnumeration();
var attributeValueEnumeration = new AttributeValueEnumeration();
attributeValueEnumeration.Definition = attributeDefinitionEnumeration;
var attributeValue = (AttributeValue)attributeValueEnumeration;
Assert.That(attributeValue.AttributeDefinition, Is.EqualTo(attributeDefinitionEnumeration));
attributeValue.AttributeDefinition = attributeDefinitionEnumeration;
Assert.That(attributeValue.AttributeDefinition, Is.EqualTo(attributeDefinitionEnumeration));
}
public void VerifyThatTheAttributeDefinitionCanBeSetOrGet()
{
var attributeDefinitionEnumeration = new AttributeDefinitionEnumeration();
var attributeValueEnumeration = new AttributeValueEnumeration();
attributeValueEnumeration.Definition = attributeDefinitionEnumeration;
var attributeValue = (AttributeValue)attributeValueEnumeration;
Assert.AreEqual(attributeDefinitionEnumeration, attributeValue.AttributeDefinition);
attributeValue.AttributeDefinition = attributeDefinitionEnumeration;
Assert.AreEqual(attributeDefinitionEnumeration, attributeValue.AttributeDefinition);
}
/// <summary>
/// Create <see cref="AttributeValue"/> For <see cref="SpecElementWithAttributes"/>
/// </summary>
/// <param name="specElementWithAttributes">
/// The <see cref="SpecElementWithAttributes"/> to which <see cref="AttributeValue"/>s need to be added.
/// </param>
/// <param name="specType">
/// The <see cref="SpecType"/> of the <see cref="specElementWithAttributes"/>
/// </param>
private void CreateValuesForSpecElementWithAttributes(SpecElementWithAttributes specElementWithAttributes, SpecType specType)
{
var attributeValueBoolean = new AttributeValueBoolean();
attributeValueBoolean.Definition = (AttributeDefinitionBoolean)specType.SpecAttributes.SingleOrDefault(x => x.GetType() == typeof(AttributeDefinitionBoolean));
attributeValueBoolean.TheValue = true;
specElementWithAttributes.Values.Add(attributeValueBoolean);
var attributeValueDate = new AttributeValueDate();
attributeValueDate.Definition = (AttributeDefinitionDate)specType.SpecAttributes.SingleOrDefault(x => x.GetType() == typeof(AttributeDefinitionDate));
attributeValueDate.TheValue = XmlConvert.ToDateTime("2015-12-01", XmlDateTimeSerializationMode.Utc);
specElementWithAttributes.Values.Add(attributeValueDate);
var attributeValueEnumeration = new AttributeValueEnumeration();
attributeValueEnumeration.Definition = (AttributeDefinitionEnumeration)specType.SpecAttributes.SingleOrDefault(x => x.GetType() == typeof(AttributeDefinitionEnumeration));
var enumValue = attributeValueEnumeration.Definition.Type.SpecifiedValues.FirstOrDefault();
attributeValueEnumeration.Values.Add(enumValue);
specElementWithAttributes.Values.Add(attributeValueEnumeration);
var attributeValueInteger = new AttributeValueInteger();
attributeValueInteger.Definition = (AttributeDefinitionInteger)specType.SpecAttributes.SingleOrDefault(x => x.GetType() == typeof(AttributeDefinitionInteger));
attributeValueInteger.TheValue = 1;
specElementWithAttributes.Values.Add(attributeValueInteger);
var attributeValueReal = new AttributeValueReal();
attributeValueReal.Definition = (AttributeDefinitionReal)specType.SpecAttributes.SingleOrDefault(x => x.GetType() == typeof(AttributeDefinitionReal));
attributeValueReal.TheValue = 100;
specElementWithAttributes.Values.Add(attributeValueReal);
var attributeValueString = new AttributeValueString();
attributeValueString.Definition = (AttributeDefinitionString)specType.SpecAttributes.SingleOrDefault(x => x.GetType() == typeof(AttributeDefinitionString));
attributeValueString.TheValue = "a string value";
specElementWithAttributes.Values.Add(attributeValueString);
var attributeValueXhtml = new AttributeValueXHTML();
attributeValueXhtml.Definition = (AttributeDefinitionXHTML)specType.SpecAttributes.SingleOrDefault(x => x.GetType() == typeof(AttributeDefinitionXHTML));
attributeValueXhtml.TheValue = this.xhtmlcontent;
specElementWithAttributes.Values.Add(attributeValueXhtml);
}
public void Verify_That_WriteXmlAsync_Throws_Exception_when_cancelled()
{
using var memoryStream = new MemoryStream();
using var writer = XmlWriter.Create(memoryStream, new XmlWriterSettings { Indent = true });
var attributeValueEnumeration = new AttributeValueEnumeration
{
Definition = new AttributeDefinitionEnumeration()
};
var cts = new CancellationTokenSource();
cts.Cancel();
Assert.That(
async() => await attributeValueEnumeration.WriteXmlAsync(writer, cts.Token),
Throws.Exception.TypeOf <OperationCanceledException>());
}
/// <summary>
/// Change ReqIF value of the specObject and the attribute value. The Attribute must be part of the ReqIF file.
/// </summary>
/// <param name="specObject"></param>
/// <param name="name"></param>
/// <param name="eaValue"></param>
/// <param name="caseSensitive"></param>
/// <returns></returns>
private bool RoundtripChangeValueReqIf(SpecObject specObject, string name, string eaValue, bool caseSensitive = false)
{
try
{
AttributeValue attrValueObject = caseSensitive
? specObject.Values.SingleOrDefault(x => x.AttributeDefinition.LongName == name)
: specObject.Values.SingleOrDefault(x =>
x.AttributeDefinition.LongName.ToLower() == name.ToLower());
// Attribute not part of ReqIF, skip
if (attrValueObject == null)
{
// Create AttributValue and assign them to values.
AttributeDefinition attributeType =
_moduleAttributeDefinitions.SingleOrDefault(x => x.LongName.ToLower() == name.ToLower());
switch (attributeType)
{
case AttributeDefinitionString _:
attrValueObject = new AttributeValueString
{
AttributeDefinition = attributeType
};
break;
case AttributeDefinitionXHTML _:
attrValueObject = new AttributeValueXHTML
{
AttributeDefinition = attributeType
};
break;
case AttributeDefinitionEnumeration moduleAttributDefinitionEnumeration:
attrValueObject = new AttributeValueEnumeration
{
AttributeDefinition = attributeType
};
break;
}
if (attrValueObject == null)
{
return(true); // not supported datatype
}
specObject.Values.Add(attrValueObject);
}
var attrType = attrValueObject.AttributeDefinition; //specObj.Values[0].AttributeDefinition.LongName;
switch (attrType)
{
case AttributeDefinitionXHTML _:
// make xhtml and handle new line
var xhtmlcontent = MakeXhtmlFromString(eaValue);
attrValueObject.ObjectValue = xhtmlcontent;
break;
case AttributeDefinitionString _:
attrValueObject.ObjectValue = eaValue;
break;
case AttributeDefinitionEnumeration _:
try
{
// take all the valid enums
if (!SetReqIfEnumValue((AttributeValueEnumeration)attrValueObject, eaValue))
{
return(false);
}
}
catch (Exception e)
{
MessageBox.Show($@"Name: '{name}'
Value: '{eaValue}'
{e}", $@"Error enumeration value TV '{name}'.");
}
break;
}
return(true);
}
catch (Exception e)
{
MessageBox.Show($@"Name: '{name}'
Value: '{eaValue}'
{e}", $@"Error value TV '{name}'.");
return(false);
}
}
/// <summary>
/// Returns the <see cref="AttributeValue"/> representation of the value of a <see cref="SimpleParameterValue"/>
/// </summary>
/// <param name="parameterType">The <see cref="ParameterType"/></param>
/// <param name="attributeDefinition">The associated <see cref="AttributeDefinition"/></param>
/// <param name="valuearray">The <see cref="ValueArray{String}"/> containing the values</param>
/// <param name="scale">The scale used</param>
/// <returns>The <see cref="AttributeValue"/></returns>
private AttributeValue ToReqIfAttributeValue(ParameterType parameterType, AttributeDefinition attributeDefinition, ValueArray <string> valuearray, MeasurementScale scale = null)
{
if (parameterType == null)
{
throw new ArgumentNullException("parameterType");
}
if (parameterType is EnumerationParameterType)
{
var enumParameterType = (EnumerationParameterType)parameterType;
var concatEnumValue = valuearray.Single();
var enumValues = concatEnumValue.Split(parameterEnumSeparator).Select(x => x.Trim()); // retrieve the list of litteral
var valueDefinitions = enumParameterType.ValueDefinition.Where(x => enumValues.Contains(x.ShortName)).ToList();
// Assuming the model is not wrong the values in the SimpleParameterValue references the ValueDefinition by its ShortName
var attributeValue = new AttributeValueEnumeration
{
Definition = (AttributeDefinitionEnumeration)attributeDefinition
};
var reqIfEnumValues = ((DatatypeDefinitionEnumeration)attributeDefinition.DatatypeDefinition).SpecifiedValues;
attributeValue.Values.AddRange(valueDefinitions.Select(x => reqIfEnumValues.Single(e => e.Properties.OtherContent == x.ShortName)));
return(attributeValue);
}
if (parameterType is DateParameterType ||
parameterType is DateTimeParameterType ||
parameterType is TimeOfDayParameterType)
{
var value = valuearray.SingleOrDefault();
DateTime date;
if (!DateTime.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out date))
{
throw new InvalidOperationException(string.Format("The string {0} cannot be parsed to a DateTime", value));
}
return(new AttributeValueDate
{
TheValue = date,
Definition = (AttributeDefinitionDate)attributeDefinition
});
}
if (parameterType is TextParameterType)
{
var value = valuearray.Single();
return(new AttributeValueString
{
TheValue = value,
Definition = (AttributeDefinitionString)attributeDefinition
});
}
if (parameterType is BooleanParameterType)
{
var value = valuearray.Single();
var boolean = Boolean.Parse(value);
return(new AttributeValueBoolean
{
TheValue = boolean,
Definition = (AttributeDefinitionBoolean)attributeDefinition
});
}
if (parameterType is QuantityKind)
{
var value = valuearray.Single();
return(new AttributeValueString
{
TheValue = string.Format("{0} [{1}]", value, scale != null ? scale.ShortName : "-"),
Definition = (AttributeDefinitionString)attributeDefinition
});
}
// CompoundParameterType
var compoundType = (CompoundParameterType)parameterType;
var theValue = "Error: The value could not be parsed.";
if (valuearray.Count() == compoundType.Component.Count)
{
var values = new List <string>();
for (var i = 0; i < valuearray.Count(); i++)
{
var component = compoundType.Component[i].Scale != null ? compoundType.Component[i].Scale.ShortName : "-";
values.Add(string.Format("{0}: {1} [{2}]", compoundType.Component[i].ShortName, valuearray[i], component));
}
theValue = string.Format("{{ {0} }}", string.Join(", ", values));
}
return(new AttributeValueString
{
TheValue = theValue,
Definition = (AttributeDefinitionString)attributeDefinition
});
}
public static Attribute Load(XElement e)
{
return(new Attribute {
Name = e.Attribute("name")?.Value,
Formats = AttributeFormat.Get(e.Attribute("format")?.Value).ToList(),
Enumerations = e.Elements("flag").Concat(e.Elements("enum")).Select(c => AttributeValueEnumeration.Load(c)).ToList()
});
}