// BUG 9634 - 2013.07.17 - TWR : added
void ReceiveEnvironmentValidation(DesignValidationMemo memo)
{
foreach (var error in memo.Errors)
{
_errors.Add(error);
}
if (OnEnvironmentValidationReceived != null)
{
OnEnvironmentValidationReceived(this, memo);
}
}
// ReSharper disable InconsistentNaming
public void EventPublisherPublish_UnitTest_RegisteredObjectType_FindsSubjectAndInvokesOnNext()
// ReSharper restore InconsistentNaming
{
var memo = new DesignValidationMemo() as object;
var publisher = new EventPublisher();
var subscription = publisher.GetEvent <DesignValidationMemo>().Subscribe(m => Assert.AreSame(memo, m));
publisher.PublishObject(memo);
subscription.Dispose();
}
public void ResourceModel_Commit_FixedErrorsNotRestored()
{
//Setup();
var eventPublisher = new EventPublisher();
var environmentModel = CreateMockEnvironment(eventPublisher);
var instanceID = Guid.NewGuid();
var model = new ResourceModel(environmentModel.Object)
{
ID = instanceID
};
var hitCount = 0;
model.OnDesignValidationReceived += (sender, memo) =>
{
switch (hitCount++)
{
case 0:
Assert.AreEqual(2, model.Errors.Count);
Assert.AreEqual(0, model.FixedErrors.Count);
break;
case 1:
Assert.AreEqual(1, model.Errors.Count);
Assert.AreEqual(1, model.FixedErrors.Count);
model.Commit();
Assert.AreEqual(1, model.Errors.Count);
Assert.AreEqual(0, model.FixedErrors.Count);
break;
}
};
// Publish 2 errors
var pubMemo = new DesignValidationMemo {
InstanceID = instanceID
};
pubMemo.Errors.Add(new ErrorInfo {
ErrorType = ErrorType.Critical, Message = "Critical error.", InstanceID = instanceID
});
pubMemo.Errors.Add(new ErrorInfo {
ErrorType = ErrorType.Warning, Message = "Warning error.", InstanceID = instanceID
});
eventPublisher.Publish(pubMemo);
// Fix 1 error and publish
pubMemo.Errors.RemoveAt(1);
eventPublisher.Publish(pubMemo);
}
public void UpdateLastValidationMemo(DesignValidationMemo memo, bool checkSource)
{
_serviceDesignerViewModel.ValidationMemoManager.LastValidationMemo = memo;
CheckRequiredMappingChangedErrors(memo);
CheckIsDeleted(memo);
_serviceDesignerViewModel.ValidationMemoManager.UpdateDesignValidationErrors(memo.Errors.Where(info => info.InstanceID == _serviceDesignerViewModel.UniqueID && info.ErrorType != ErrorType.None));
if (_serviceDesignerViewModel.SourceId == Guid.Empty && checkSource && _serviceDesignerViewModel.CheckSourceMissing())
{
InitializeMappings();
UpdateMappings();
}
}
public void UpdateLastValidationMemoWithVersionChanged()
{
var memo = new DesignValidationMemo
{
InstanceID = _serviceDesignerViewModel.UniqueID,
IsValid = false,
};
memo.Errors.Add(new ErrorInfo
{
InstanceID = _serviceDesignerViewModel.UniqueID,
ErrorType = ErrorType.Critical,
FixType = FixType.ReloadMapping,
Message = @"Incorrect Version. The remote workflow has changed.Please refresh"
});
_serviceDesignerViewModel.MappingManager.UpdateLastValidationMemo(memo, false);
}
public void ClearValidationMemoWithNoFoundError()
{
var memo = new DesignValidationMemo
{
InstanceID = UniqueID,
IsValid = false,
};
memo.Errors.Add(new ErrorInfo
{
InstanceID = UniqueID,
ErrorType = ErrorType.None,
FixType = FixType.None,
Message = ""
});
UpdateDesignValidationErrors(memo.Errors);
}
void UpdateLastValidationMemoWithDeleteError()
{
var memo = new DesignValidationMemo
{
InstanceID = UniqueID,
IsValid = false,
};
memo.Errors.Add(new ErrorInfo
{
InstanceID = UniqueID,
ErrorType = ErrorType.Warning,
FixType = FixType.Delete,
Message = "Resource was not found. This service will not execute."
});
UpdateLastValidationMemo(memo);
}
void CheckRequiredMappingChangedErrors(DesignValidationMemo memo)
{
var keepError = false;
var reqiredMappingChanged = memo.Errors.FirstOrDefault(c => c.FixType == FixType.IsRequiredChanged);
if (reqiredMappingChanged != null)
{
keepError = KeepError(reqiredMappingChanged);
if (!keepError)
{
var worstErrors = memo.Errors.Where(c => c.FixType == FixType.IsRequiredChanged && c.InstanceID == _serviceDesignerViewModel.UniqueID).ToList();
memo.Errors.RemoveAll(c => c.FixType == FixType.IsRequiredChanged && c.InstanceID == _serviceDesignerViewModel.UniqueID);
_serviceDesignerViewModel.ValidationMemoManager.RemoveErrors(worstErrors);
}
}
}
void UpdateLastValidationMemoWithSourceNotFoundError()
{
var memo = new DesignValidationMemo
{
InstanceID = UniqueID,
IsValid = false,
};
memo.Errors.Add(new ErrorInfo
{
InstanceID = UniqueID,
ErrorType = ErrorType.Critical,
FixType = FixType.None,
Message = _sourceNotFoundMessage
});
UpdateDesignValidationErrors(memo.Errors);
}
void CheckIsDeleted(DesignValidationMemo memo)
{
var error = memo.Errors.FirstOrDefault(c => c.FixType == FixType.Delete);
_serviceDesignerViewModel.IsDeleted = error != null;
_serviceDesignerViewModel.IsEditable = !_serviceDesignerViewModel.IsDeleted;
if (_serviceDesignerViewModel.IsDeleted)
{
while (memo.Errors.Count > 1)
{
error = memo.Errors.FirstOrDefault(c => c.FixType != FixType.Delete);
if (error != null)
{
memo.Errors.Remove(error);
}
}
}
}
private void UpdateLastValidationMemoWithVersionChanged()
{
var memo = new DesignValidationMemo
{
InstanceID = UniqueID,
IsValid = false,
};
memo.Errors.Add(new ErrorInfo
{
InstanceID = UniqueID,
ErrorType = ErrorType.Critical,
FixType = FixType.ReloadMapping,
Message = "Incorrect Version. The remote workflow has changed.Please refresh"
});
UpdateLastValidationMemo(memo, false);
}
public void ResourceModel_DesignValidationServicePublishingMemo_UpdatesErrors()
{
//Setup();
var instanceID = Guid.NewGuid();
var pubMemo = new DesignValidationMemo {
InstanceID = instanceID
};
pubMemo.Errors.Add(new ErrorInfo {
ErrorType = ErrorType.Critical, Message = "Critical error.", InstanceID = instanceID
});
pubMemo.Errors.Add(new ErrorInfo {
ErrorType = ErrorType.Warning, Message = "Warning error.", InstanceID = instanceID
});
var eventPublisher = new EventPublisher();
var connection = new Mock <IEnvironmentConnection>();
connection.Setup(e => e.ServerEvents).Returns(eventPublisher);
var environmentModel = new Mock <IServer>();
environmentModel.Setup(e => e.Connection).Returns(connection.Object);
var model = new ResourceModel(environmentModel.Object)
{
ID = instanceID
};
model.OnDesignValidationReceived += (sender, memo) =>
{
Assert.AreEqual(memo.Errors.Count, model.Errors.Count, "OnDesignValidationReceived did not update the number of errors correctly.");
foreach (var error in memo.Errors)
{
var error1 = error;
var modelError = model.Errors.FirstOrDefault(me => me.ErrorType == error1.ErrorType && me.Message == error1.Message);
Assert.AreSame(error, modelError, "OnDesignValidationReceived did not set the error.");
}
};
eventPublisher.Publish(pubMemo);
}
void CheckIsDeleted(DesignValidationMemo memo)
{
// BUG 9940 - 2013.07.30 - TWR - added
var error = memo.Errors.FirstOrDefault(c => c.FixType == FixType.Delete);
IsDeleted = error != null;
IsEditable = !IsDeleted;
if (IsDeleted)
{
while (memo.Errors.Count > 1)
{
error = memo.Errors.FirstOrDefault(c => c.FixType != FixType.Delete);
if (error != null)
{
memo.Errors.Remove(error);
}
}
}
}
void UpdateLastValidationMemo(DesignValidationMemo memo, bool checkSource = true)
{
LastValidationMemo = memo;
CheckRequiredMappingChangedErrors(memo);
CheckIsDeleted(memo);
UpdateDesignValidationErrors(memo.Errors.Where(info => info.InstanceID == UniqueID && info.ErrorType != ErrorType.None));
if (SourceId == Guid.Empty)
{
if (checkSource && CheckSourceMissing())
{
InitializeMappings();
UpdateMappings();
}
}
if (OnDesignValidationReceived != null)
{
OnDesignValidationReceived(this, memo);
}
}
public void ResourceModel_Environment_DesignValidationService_WiredUp()
{
var eventPublisher = new EventPublisher();
var environmentID = Guid.NewGuid();
var environment = new Mock <IEnvironmentModel>();
environment.Setup(e => e.ID).Returns(environmentID);
environment.Setup(e => e.Connection.ServerEvents).Returns(eventPublisher);
var instanceID = Guid.NewGuid();
var model = new ResourceModel(environment.Object, new Mock <IEventAggregator>().Object);
var errors = model.GetErrors(instanceID);
Assert.AreEqual(0, errors.Count);
var err = new ErrorInfo
{
InstanceID = instanceID,
};
var memo = new DesignValidationMemo
{
InstanceID = environmentID,
Errors = new List <IErrorInfo>
{
err
}
};
//------------Execute Test---------------------------
eventPublisher.Publish(memo);
//------------Assert Results-------------------------
errors = model.GetErrors(instanceID);
Assert.AreEqual(1, errors.Count);
Assert.AreSame(err, errors[0]);
}
void CheckRequiredMappingChangedErrors(DesignValidationMemo memo)
{
var keepError = false;
var reqiredMappingChanged = memo.Errors.FirstOrDefault(c => c.FixType == FixType.IsRequiredChanged);
if (reqiredMappingChanged != null)
{
if (reqiredMappingChanged.FixData != null)
{
var xElement = XElement.Parse(reqiredMappingChanged.FixData);
var inputOutputViewModels = DeserializeMappings(true, xElement);
foreach (var input in inputOutputViewModels)
{
IInputOutputViewModel currentInputViewModel = input;
if (DataMappingViewModel != null)
{
var inputOutputViewModel = DataMappingViewModel.Inputs.FirstOrDefault(c => c.Name == currentInputViewModel.Name);
if (inputOutputViewModel != null)
{
inputOutputViewModel.Required = input.Required;
if (inputOutputViewModel.MapsTo == string.Empty && inputOutputViewModel.Required)
{
keepError = true;
}
}
}
}
}
if (!keepError)
{
var worstErrors = memo.Errors.Where(c => c.FixType == FixType.IsRequiredChanged && c.InstanceID == UniqueID).ToList();
memo.Errors.RemoveAll(c => c.FixType == FixType.IsRequiredChanged && c.InstanceID == UniqueID);
RemoveErrors(worstErrors);
}
}
}
private void AuthorizationServiceOnPermissionsChanged(object sender, EventArgs eventArgs)
{
ValidationMemoManager.RemovePermissionsError();
var hasNoPermission = HasNoPermission();
if (hasNoPermission)
{
var memo = new DesignValidationMemo
{
InstanceID = UniqueID,
IsValid = false,
};
memo.Errors.Add(new ErrorInfo
{
InstanceID = UniqueID,
ErrorType = ErrorType.Critical,
FixType = FixType.InvalidPermissions,
Message = ErrorResource.NoPermissionToExecuteTool
});
MappingManager.UpdateLastValidationMemo(memo);
}
}
void ReceiveDesignValidation(DesignValidationMemo memo)
{
if (memo.Errors.Any(info => info.InstanceID != Guid.Empty))
{
IsValid = memo.IsValid && _errors.Count == 0;
if (memo.Errors.Count > 0)
{
foreach (var error in Errors.Where(error => !memo.Errors.Contains(error)))
{
_fixedErrors.Add(error);
}
if (_errors.Count > 0)
{
_errors.Clear();
}
foreach (var error in memo.Errors)
{
_errors.Add(error);
}
}
}
OnDesignValidationReceived?.Invoke(this, memo);
}
void AuthorizationServiceOnPermissionsChanged(object sender, EventArgs eventArgs)
{
RemovePermissionsError();
var hasNoPermission = HasNoPermission();
if (hasNoPermission)
{
var memo = new DesignValidationMemo
{
InstanceID = UniqueID,
IsValid = false,
};
memo.Errors.Add(new ErrorInfo
{
InstanceID = UniqueID,
ErrorType = ErrorType.Critical,
FixType = FixType.InvalidPermissions,
Message = "You do not have permissions to View or Execute this resource."
});
UpdateLastValidationMemo(memo);
}
}
public void UpdateLastValidationMemo(DesignValidationMemo memo) => UpdateLastValidationMemo(memo, true);
static void CoalesceResourceSavedErrors(DesignValidationMemo memo, ICompileMessageTO compilerMessage)
{
memo.ServiceID = compilerMessage.ServiceID;
memo.IsValid = true;
}
static void CoalesceMappingChangedErrors(DesignValidationMemo memo, ICompileMessageTO compilerMessage)
{
memo.ServiceID = compilerMessage.ServiceID;
memo.IsValid = false;
memo.Errors.Add(compilerMessage.ToErrorInfo());
}
