public void PasteCommandExecutedTest()
{
_service.ClipboardHelperStub.Setup(h => h.GetText())
.Returns("2\titem22\tTrue\r\n\titem3\tTrue\r\n4\titem3\tTrue");
var item1 = new DataErrorInfo {
Id = 1, Name = "item1", Property = true
};
var item2 = new DataErrorInfo {
Id = 2, Name = "item2", Property = false
};
_viewModel.PostReloadItemsToInsert.Add(item1);
_viewModel.PostReloadItemsToInsert.Add(item2);
_viewModel.Reload();
_viewModel.PasteCommand.Execute(null);
_service.ClipboardHelperStub.Verify();
Assert.AreEqual(3, _viewModel.Collection.Count);
Assert.Contains(item1, _viewModel.Collection);
Assert.AreEqual(1, item1.Id);
Assert.AreEqual("item1", item1.Name);
Assert.AreEqual(true, item1.Property);
Assert.Contains(item2, _viewModel.Collection);
Assert.AreEqual(2, item2.Id);
Assert.AreEqual("item22", item2.Name);
Assert.AreEqual(true, item2.Property);
DataErrorInfo added = _viewModel.Collection.Last();
Assert.AreEqual(0, added.Id);
Assert.AreEqual("item3", added.Name);
Assert.AreEqual(true, added.Property);
}
/// <summary>
/// Handles the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="response">The response.</param>
protected override void Handle(CreateSystemAdminRequest request, DtoResponse <SystemAccountDto> response)
{
var systemAccount = _systemAccountRepository.GetByIdentifier(request.Email);
var roleKey = _roleRepository.GetInternalRoleKeyByName("System Admin");
if (roleKey.HasValue)
{
if (systemAccount == null)
{
var result = _systemAccountIdentityServiceManager.Create(request.Email);
if (result.Sucess)
{
var systemAccountFactory = new SystemAccountFactory();
systemAccount = systemAccountFactory.Create(Guid.Empty, request.Email, new Email(request.Email));
systemAccount.AddRole(roleKey.Value);
var systemAccountDto = Mapper.Map <SystemAccount, SystemAccountDto> (systemAccount);
response.DataTransferObject = systemAccountDto;
}
else
{
var dataErrorInfo = new DataErrorInfo(result.ErrorMessage, ErrorLevel.Error);
response.DataTransferObject = new SystemAccountDto();
response.DataTransferObject.AddDataErrorInfo(dataErrorInfo);
}
}
else
{
var dataErrorInfo = new DataErrorInfo("System Admin already exists.", ErrorLevel.Error);
response.DataTransferObject = new SystemAccountDto();
response.DataTransferObject.AddDataErrorInfo(dataErrorInfo);
}
}
}
public void EditCommandExecutedTest(bool dialogReturnValue)
{
var clone = new Meta();
_editDialogStub.Setup(d => d.ShowDialog()).Returns(dialogReturnValue).Callback(() => {
clone.Property = true;
});
var info = new DataErrorInfo();
_service.EditorHelperStub.Setup(h => h.Update(clone, info)).Callback(() => {
info.Property = clone.Property;
});
_viewModel.PostReloadItemsToInsert.Add(info);
_viewModel.Reload();
_viewModel.SelectedItem = info;
_service.EditorHelperStub.Setup(h => h.Clone(info)).Returns(clone);
_viewModel.EditCommand.Execute(null);
_editDialogStub.Verify();
if (dialogReturnValue)
{
Assert.IsTrue(info.Property);
_service.EditorHelperStub.Verify(h => h.Update(clone, info), Times.Once());
}
else
{
Assert.IsFalse(info.Property);
_service.EditorHelperStub.Verify(h => h.Update(clone, info), Times.Never());
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AddSelfPaymentViewModelRuleCollection"/> class.
/// </summary>
public AddSelfPaymentViewModelRuleCollection()
{
AutoValidatePropertyRules = true;
var amountError = new DataErrorInfo(
"Amount must be greater then 0.",
ErrorLevel.Error,
PropertyUtil.ExtractPropertyName <SelfPaymentDto, object> (dto => dto.Amount));
NewPropertyRule(() => AmountMustBeGreaterThanZero)
.WithProperty(s => s.SelfPayment.Amount)
.GreaterThan(0)
.ElseThen(s => s.SelfPayment.AddDataErrorInfo(amountError))
.Then(s => s.SelfPayment.RemoveDataErrorInfo(amountError));
var paymentMethodError = new DataErrorInfo(
"Payment Method is required.",
ErrorLevel.Error,
PropertyUtil.ExtractPropertyName <SelfPaymentDto, object> (dto => dto.PaymentMethod));
NewPropertyRule(() => PaymentMethodIsRequired)
.WithProperty(s => s.SelfPayment.PaymentMethod)
.NotNull()
.ElseThen(s => s.SelfPayment.AddDataErrorInfo(paymentMethodError))
.Then(s => s.SelfPayment.RemoveDataErrorInfo(paymentMethodError));
}
public void DeleteCommandExecutedTest(bool dialogReturnValue)
{
_service.DialogHelperStub
.Setup(h => h.Message(
It.IsAny <string>(), It.IsAny <string>(), MessageBoxButton.YesNo, MessageBoxImage.Question,
It.IsAny <object>()))
.Returns(dialogReturnValue);
var info = new DataErrorInfo();
var info2 = new DataErrorInfo();
var info3 = new DataErrorInfo();
_viewModel.PostReloadItemsToInsert.Add(info);
_viewModel.PostReloadItemsToInsert.Add(info2);
_viewModel.PostReloadItemsToInsert.Add(info3);
_viewModel.Reload();
_viewModel.SelectedItems.Add(info);
_viewModel.SelectedItems.Add(info3);
_viewModel.DeleteCommand.Execute(null);
if (dialogReturnValue)
{
Assert.AreEqual(1, _viewModel.Collection.Count);
Assert.AreEqual(info2, _viewModel.Collection[0]);
_contextStub.Verify(c => c.DeleteObject(info), Times.Once());
_contextStub.Verify(c => c.DeleteObject(info3), Times.Once());
}
else
{
Assert.AreEqual(3, _viewModel.Collection.Count);
Assert.AreEqual(info, _viewModel.Collection[0]);
Assert.AreEqual(info2, _viewModel.Collection[1]);
Assert.AreEqual(info3, _viewModel.Collection[2]);
_contextStub.Verify(c => c.DeleteObject(It.IsAny <object>()), Times.Never());
}
}
protected override void Handle(CreateSystemAdminRequest request, DtoResponse <SystemAccountDto> response)
{
var systemAccount = _systemAccountRepository.GetByIdentifier(request.Email);
var role = _roleRepository.GetInternalRoleKeyByName("System Admin");
if (role != null)
{
if (systemAccount == null)
{
var identityServiceResponse = _systemAccountIdentityServiceManager.Create(request.Username, request.Email);
if (identityServiceResponse.Sucess)
{
systemAccount = _systemAccountFactory.CreateSystemAdmin(request.Email, new Email(request.Email));
var systemAccountDto = Mapper.Map <SystemAccount, SystemAccountDto>(systemAccount);
response.DataTransferObject = systemAccountDto;
systemAccount.AddRole(role);
}
else
{
var result = identityServiceResponse.ErrorMessage;
var dataErrorInfo = new DataErrorInfo(result, ErrorLevel.Error);
response.DataTransferObject = new SystemAccountDto();
response.DataTransferObject.AddDataErrorInfo(dataErrorInfo);
}
}
else
{
var result = "System account already in use.";
var dataErrorInfo = new DataErrorInfo(result, ErrorLevel.Error);
response.DataTransferObject = new SystemAccountDto();
response.DataTransferObject.AddDataErrorInfo(dataErrorInfo);
}
}
}
public void ClearAllDataErrorInfo_ErrorsChangedEventShouldFire()
{
var personDto = new TestPersonDto {
FirstName = "John", LastName = "Wayne"
};
var objectDataErrorInfo1 = new DataErrorInfo("ObjectLevelError1", ErrorLevel.Error);
var objectDataErrorInfo2 = new DataErrorInfo("ObjectLevelError2", ErrorLevel.Error);
var propertyDataErrorInfo = new DataErrorInfo("PropertyLevelError", ErrorLevel.Error, "FirstName");
var crossDataErrorInfo = new DataErrorInfo("CrossPropertyLevelError", ErrorLevel.Error, "FirstName",
"LastName");
HashSet <string> referenceNames = new HashSet <string> {
"FirstName", "", "LastName"
};
HashSet <string> propertyNames = new HashSet <string> ();
personDto.AddDataErrorInfo(objectDataErrorInfo1);
personDto.AddDataErrorInfo(objectDataErrorInfo2);
personDto.AddDataErrorInfo(propertyDataErrorInfo);
personDto.AddDataErrorInfo(crossDataErrorInfo);
personDto.ErrorsChanged += (s, e) => propertyNames.Add(e.PropertyName);
personDto.ClearAllDataErrorInfo();
AssertSetsEqual(referenceNames, propertyNames);
}
public void OkCommandCanExecuteReturnsEntityHasError(DataErrorInfo entity)
{
_viewModel.Entity = entity;
if (entity == null)
Assert.IsFalse(_viewModel.OkCommand.CanExecute(null));
else
Assert.AreEqual(string.IsNullOrEmpty(entity.Error), _viewModel.OkCommand.CanExecute(null));
}
public void SetEntityRaisesOkCommandCanExecuteChanged(DataErrorInfo entity)
{
var raised = false;
_viewModel.OkCommand.CanExecuteChanged += (sender, args) => { raised = true; };
_viewModel.Entity = entity;
Assert.IsTrue(raised);
}
public void SetSelectedItemRaisesUnselectCommandCanExecuteChanged(DataErrorInfo value)
{
var raised = false;
_viewModel.UnselectCommand.CanExecuteChanged += (sender, args) => { raised = true; };
_viewModel.SelectedItem = value;
Assert.IsTrue(raised);
}
/// <summary>
/// Handles the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="response">The response.</param>
protected override void Handle(CreateOrganizationAdminRequest request, CreateOrganizationAdminResponse response)
{
var systemAccount = _systemAccountRepository.GetByIdentifier(request.Email);
var addRole = false;
if (systemAccount == null)
{
var result = _systemAccountIdentityServiceManager.Create(request.Email);
if (result.Sucess)
{
var systemAccountFactory = new SystemAccountFactory();
systemAccount = systemAccountFactory.Create(request.OrganizationKey, request.Email, new Email(request.Email));
var systemAccountDto = Mapper.Map <SystemAccount, SystemAccountDto> (systemAccount);
response.SystemAccountDto = systemAccountDto;
addRole = true;
}
else
{
var dataErrorInfo = new DataErrorInfo(result.ErrorMessage, ErrorLevel.Error);
response.SystemAccountDto = new SystemAccountDto();
response.SystemAccountDto.AddDataErrorInfo(dataErrorInfo);
}
}
else
{
var result = _systemAccountIdentityServiceManager.ResetPassword(systemAccount.Identifier);
if (result.Sucess)
{
var systemAccountDto = Mapper.Map <SystemAccount, SystemAccountDto> (systemAccount);
response.SystemAccountDto = systemAccountDto;
addRole = true;
}
else
{
var dataErrorInfo = new DataErrorInfo(result.ErrorMessage, ErrorLevel.Error);
response.SystemAccountDto = new SystemAccountDto();
response.SystemAccountDto.AddDataErrorInfo(dataErrorInfo);
}
}
if (addRole)
{
var role = _roleFactory.Create("Default Organization Admin", request.OrganizationKey);
role.AddPermision(BasicAccessPermission.AccessUserInterfacePermission);
role.AddPermision(OrganizationPermission.OrganizationViewPermission);
role.AddPermision(OrganizationPermission.OrganizationEditPermission);
role.AddPermision(StaffPermission.StaffAddRolePermission);
role.AddPermision(StaffPermission.StaffCreateAccountPermission);
role.AddPermision(StaffPermission.StaffEditPermission);
role.AddPermision(StaffPermission.StaffLinkAccountPermission);
role.AddPermision(StaffPermission.StaffRemoveRolePermission);
role.AddPermision(StaffPermission.StaffViewPermission);
role.AddPermision(RolePermission.RoleAddPermissionPermission);
role.AddPermision(RolePermission.RoleEditPermission);
role.AddPermision(RolePermission.RoleRemovePermissionPermission);
role.AddPermision(RolePermission.RoleViewPermission);
systemAccount.AddRole(role.Key);
}
}
public void AddDataErrorInfo_NonExistingSingleProperty_ThrowsPropertyNotFoundException()
{
var personDto = new PersonDto {
FirstName = "John", LastName = "Wayne"
};
var dataErrorInfo = new DataErrorInfo("NonExistingProperty", ErrorLevel.Error, "Foo");
personDto.AddDataErrorInfo(dataErrorInfo);
}
public void DataTransferObject_NonExistingCrossProperty_ThrowsPropertyNotFoundException()
{
var personDto = new PersonDto {
FirstName = "John", LastName = "Wayne"
};
var dataErrorInfo = new DataErrorInfo("NonExistingCrossProperty", ErrorLevel.Error, "FirstName", "Foo");
personDto.AddDataErrorInfo(dataErrorInfo);
}
private void BuildAddressRules()
{
var firstAddressError = new DataErrorInfo(
"Address line 1 is required.",
ErrorLevel.Error,
PropertyUtil.ExtractPropertyName <PayorTypeDto, object>(dto => dto.FirstStreetAddress));
NewPropertyRule(() => FirstAddressRequired)
.WithProperty(s => s.EditingDto.FirstStreetAddress)
.NotEmpty()
.ElseThen(
(s, ctx) =>
{
if (!(ctx.RuleSelector is SelectAllRuleSelector))
{
s.EditingDto.TryAddDataErrorInfo(firstAddressError);
}
})
.Then(s => s.EditingDto.RemoveDataErrorInfo(firstAddressError));
var cityError = new DataErrorInfo(
"City is required.",
ErrorLevel.Error,
PropertyUtil.ExtractPropertyName <PayorTypeDto, object>(dto => dto.CityName));
NewPropertyRule(() => CityRequired)
.WithProperty(s => s.EditingDto.CityName)
.NotEmpty()
.ElseThen(
(s, ctx) =>
{
if (!(ctx.RuleSelector is SelectAllRuleSelector))
{
s.EditingDto.TryAddDataErrorInfo(cityError);
}
})
.Then(s => s.EditingDto.RemoveDataErrorInfo(cityError));
var stateError = new DataErrorInfo(
"State is required.",
ErrorLevel.Error,
PropertyUtil.ExtractPropertyName <PayorTypeDto, object>(dto => dto.StateProvince));
NewPropertyRule(() => StateRequired)
.WithProperty(s => s.EditingDto.FirstStreetAddress)
.NotNull()
.ElseThen(
(s, ctx) =>
{
if (!(ctx.RuleSelector is SelectAllRuleSelector))
{
s.EditingDto.TryAddDataErrorInfo(stateError);
}
})
.Then(s => s.EditingDto.RemoveDataErrorInfo(stateError));
}
public void SemanticComparisonAgainstDataErrorInfoWillNotThrow()
{
// Fixture setup
var likenObject = new DataErrorInfo();
var comparee = new DataErrorInfo();
// The rest of the test
CompareSemantically(likenObject, comparee, true);
}
/// <summary>
/// Initializes a new instance of the <see cref="PayorEditorViewModelRuleCollection"/> class.
/// </summary>
public PayorEditorViewModelRuleCollection()
{
AutoValidatePropertyRules = true;
var nameError = new DataErrorInfo(
"Name is required.",
ErrorLevel.Error,
PropertyUtil.ExtractPropertyName <PayorProfileDto, object> (dto => dto.Name));
NewPropertyRule(() => NameRequired)
.WithProperty(s => s.EditingDto.Profile.Name)
.NotEmpty()
.ElseThen(
(s, ctx) =>
{
if (!(ctx.RuleSelector is SelectAllRuleSelector))
{
s.EditingDto.Profile.TryAddDataErrorInfo(nameError);
}
})
.Then(s => s.EditingDto.Profile.RemoveDataErrorInfo(nameError));
var primaryPayorTypeError = new DataErrorInfo(
"Primary payor type is required.",
ErrorLevel.Error,
PropertyUtil.ExtractPropertyName <PayorProfileDto, object> (dto => dto.PrimaryPayorType));
NewPropertyRule(() => PrimaryPayorTypeRequired)
.WithProperty(s => s.EditingDto.Profile.PrimaryPayorType)
.NotNull()
.ElseThen(
(s, ctx) =>
{
if (!(ctx.RuleSelector is SelectAllRuleSelector))
{
s.EditingDto.Profile.TryAddDataErrorInfo(primaryPayorTypeError);
}
})
.Then(s => s.EditingDto.Profile.RemoveDataErrorInfo(primaryPayorTypeError));
var regex = new Regex(@"^\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$");
var emailAddressInvalidError = new DataErrorInfo(
"Email address is not valid.",
ErrorLevel.Error,
PropertyUtil.ExtractPropertyName <PayorProfileDto, object> (dto => dto.EmailAddress));
NewRule(() => EmailAddressInvalid)
.RunForProperty(s => s.EditingDto.Profile.EmailAddress)
.When(
s => (s.EditingDto.Profile.EmailAddress != null &&
!regex.IsMatch(s.EditingDto.Profile.EmailAddress)))
.ThenReportRuleViolation(emailAddressInvalidError.Message)
.Then(s => s.EditingDto.Profile.TryAddDataErrorInfo(emailAddressInvalidError))
.ElseThen(s => s.EditingDto.Profile.RemoveDataErrorInfo(emailAddressInvalidError));
}
public void SetEntityRaisesPropertyChanged(DataErrorInfo entity)
{
var raised = false;
_viewModel.PropertyChanged += (sender, args) =>
{
if (args.PropertyName == "Entity")
raised = true;
};
_viewModel.Entity = entity;
Assert.IsTrue(raised);
}
public void EntityErrorPropertyChangedRaisesOkCommandCanExecutedChanged()
{
var entity = new DataErrorInfo();
_viewModel.Entity = entity;
var raised = false;
_viewModel.OkCommand.CanExecuteChanged += (sender, args) => { raised = true; };
entity.OnPropertyChanged("Error");
Assert.IsTrue(raised);
}
public void EntityPropertyChangedDoesNotRaiseOkCommandCanExecutedChangedIfEntitySetOther()
{
var entity = new DataErrorInfo();
_viewModel.Entity = entity;
_viewModel.Entity = null;
var raised = false;
_viewModel.OkCommand.CanExecuteChanged += (sender, args) => { raised = true; };
entity.OnPropertyChanged(null);
Assert.IsFalse(raised);
}
public void RemoveDataErrorInfo_ProvidedAnEmptyProperty_RemovesObjectLevelErrors()
{
var personDto = new PersonDto {
FirstName = "John", LastName = "Wayne"
};
var dataErrorInfo = new DataErrorInfo("SomeErrorMessage", ErrorLevel.Error);
personDto.AddDataErrorInfo(dataErrorInfo);
personDto.RemoveDataErrorInfo("");
Assert.IsTrue(personDto.DataErrorInfoCollection.Count() == 0);
}
public void RemoveDataErrorInfo_OnePropertyLevelError_RemovesPropertyLevelError()
{
var personDto = new PersonDto {
FirstName = "John", LastName = "Wayne"
};
var dataErrorInfo = new DataErrorInfo("SomeErrorMessage1", ErrorLevel.Error, "FirstName");
personDto.AddDataErrorInfo(dataErrorInfo);
personDto.RemoveDataErrorInfo("FirstName");
Assert.IsTrue(personDto.DataErrorInfoCollection.Count() == 0);
}
public void RemoveDataErrorInfo_ProvidedANonExistentProperty_ThrowAPropertyNotFoundException()
{
var personDto = new PersonDto {
FirstName = "John", LastName = "Wayne"
};
var dataErrorInfo = new DataErrorInfo("SomeErrorMessage", ErrorLevel.Error);
personDto.AddDataErrorInfo(dataErrorInfo);
personDto.RemoveDataErrorInfo("Foo");
Assert.IsTrue(personDto.DataErrorInfoCollection.Count() == 0);
}
public void IsValidReturnsFalseIfAnyItemIsInvalid()
{
var one = new DataErrorInfo {
HasError = false, Name = "one"
};
var two = new DataErrorInfo {
HasError = true, Name = "two"
};
_viewModel.SetDataErrorInfo(one);
_viewModel.SetDataErrorInfo(two);
Assert.IsFalse(_viewModel.IsValid);
}
public void IsValidReturnsFalseIfDublicateItemsNames()
{
var one = new DataErrorInfo {
HasError = false, Name = "name"
};
var two = new DataErrorInfo {
HasError = false, Name = "name"
};
_viewModel.SetDataErrorInfo(one);
_viewModel.SetDataErrorInfo(two);
Assert.IsFalse(_viewModel.IsValid);
}
public void IsValidReturnsTrueIfAllItemsAreValid()
{
var one = new DataErrorInfo {
HasError = false, Name = "one"
};
var two = new DataErrorInfo {
HasError = false, Name = "two"
};
_viewModel.SetDataErrorInfo(one);
_viewModel.SetDataErrorInfo(two);
Assert.IsTrue(_viewModel.IsValid);
}
public void SelectedItemSetRaisesOnPropertyChanged(DataErrorInfo value)
{
var raised = false;
_viewModel.PropertyChanged += (sender, args) => {
if (args.PropertyName == "SelectedItem")
{
raised = true;
}
};
_viewModel.SelectedItem = value;
Assert.IsTrue(raised);
}
public void RemoveDataErrorInfo_RemovingAnObjectLevelError_ErrorsChangedEventShouldFire()
{
var personDto = new TestPersonDto {
FirstName = "John", LastName = "Wayne"
};
var dataErrorInfo = new DataErrorInfo("EntityLevelError", ErrorLevel.Error);
string propertyName = "Dummy";
personDto.AddDataErrorInfo(dataErrorInfo);
personDto.ErrorsChanged += (s, e) => { propertyName = e.PropertyName; };
personDto.RemoveDataErrorInfo(String.Empty);
Assert.IsTrue(string.IsNullOrEmpty(propertyName));
}
public void GetErrors_WithAPropertyNameButOnlyAnObjectLevelErrorExists_ReturnAnEmptyList()
{
var personDto = new TestPersonDto {
FirstName = "John", LastName = "Wayne"
};
DataErrorInfo dataErrorInfo = new DataErrorInfo("Error", ErrorLevel.Error);
personDto.AddDataErrorInfo(dataErrorInfo);
IEnumerable <DataErrorInfo> errors = personDto.GetErrors("FirstName") as IEnumerable <DataErrorInfo>;
IList <DataErrorInfo> errorList = new List <DataErrorInfo> (errors);
Assert.IsTrue(errorList.Count() == 0);
}
public void CopyCommandExecutedTest()
{
var item1 = new DataErrorInfo {
id = 1, name = "item1", Property = true
};
var item2 = new DataErrorInfo {
id = 2, name = "item2", Property = false
};
_viewModel.SelectedItems.Add(item1);
_viewModel.SelectedItems.Add(item2);
_viewModel.CopyCommand.Execute(null);
_service.ClipboardHelperStub.Verify(h => h.SetText("id\tname\tProperty\r\n1\titem1\tTrue\r\n2\titem2\tFalse"));
}
public void RemoveDataErrorInfo_RemovingAPropertyLevelError_ErrorsChangedEventShouldFire()
{
var personDto = new TestPersonDto {
FirstName = "John", LastName = "Wayne"
};
var dataErrorInfo = new DataErrorInfo("EntityLevelError", ErrorLevel.Error, "FirstName");
string propertyName = "Dummy";
personDto.AddDataErrorInfo(dataErrorInfo);
personDto.ErrorsChanged += (s, e) => { propertyName = e.PropertyName; };
personDto.RemoveDataErrorInfo("FirstName");
Assert.AreEqual(propertyName, "FirstName");
}
/// <summary>
/// Maps the exception to <see cref="DataErrorInfo"/>.
/// </summary>
/// <param name="dto">
/// The dto to which the <see cref="DataErrorInfo"/> belongs.
/// </param>
/// <param name="exception">
/// The exception.
/// </param>
public static void MapExceptionToDataErrorInfo(
AbstractDataTransferObject dto,
Exception exception )
{
DataErrorInfo error;
if ( exception is ArgumentException )
{
string propertyName = ( exception as ArgumentException ).ParamName;
var hasProperty = !string.IsNullOrEmpty ( propertyName ) && dto.GetType ().GetProperty ( propertyName ) != null;
error = hasProperty
? new DataErrorInfo ( exception.Message, ErrorLevel.Error, propertyName )
: new DataErrorInfo ( exception.Message, ErrorLevel.Error );
}
else
{
error = new DataErrorInfo ( exception.Message, ErrorLevel.Error );
}
dto.AddDataErrorInfo ( error );
}
