public void SaveSchema(ServiceParameters serviceParameters, HashSet <string> inputCheckedEntity, Dictionary <string, HashSet <string> > inputEntityRelationships, Dictionary <string, HashSet <string> > inputEntityAttributes, AttributeTypeMapping inputAttributeMapping, CrmSchemaConfiguration inputCrmSchemaConfiguration, TextBox schemaPathTextBox)
{
if (AreCrmEntityFieldsSelected(inputCheckedEntity, inputEntityRelationships, inputEntityAttributes, inputAttributeMapping, serviceParameters))
{
CollectCrmEntityFields(inputCheckedEntity, inputCrmSchemaConfiguration, inputEntityRelationships, inputEntityAttributes, inputAttributeMapping, serviceParameters);
GenerateXMLFile(schemaPathTextBox, inputCrmSchemaConfiguration);
inputCrmSchemaConfiguration.Entities.Clear();
}
else
{
serviceParameters.NotificationService.DisplayFeedback("Please select at least one attribute for each selected entity!");
}
}
public NonEoiNotPermittedFilterAttribute(
ServiceParameters serviceParameters,
IEncodingService encodingService,
IMediator mediator,
IExternalUrlHelper urlHelper,
ILogger <NonEoiNotPermittedFilterAttribute> logger)
{
_serviceParameters = serviceParameters;
_encodingService = encodingService;
_mediator = mediator;
_urlHelper = urlHelper;
_logger = logger;
}
public async Task And_Is_Provider_Then_Executes_Action(
[Frozen] ServiceParameters serviceParameters,
[ArrangeActionContext] ActionExecutingContext context,
Mock <ActionExecutionDelegate> mockNext,
NonEoiNotPermittedFilterAttribute filter)
{
serviceParameters.AuthenticationType = AuthenticationType.Provider;
await filter.OnActionExecutionAsync(context, mockNext.Object);
mockNext.Verify(next => next(), Times.Once);
context.Result.Should().Be(null);
}
/// <summary>
/// Validate the CancelRequest()
/// </summary>
/// <param name="nodeName">xml node name</param>
void ValidateCancelRequest(string nodeName)
{
// Read input from config file
string filepath = Utility._xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string emailId = Utility._xmlUtil.GetTextValue(nodeName,
Constants.EmailIDNode);
string clusterOption = Utility._xmlUtil.GetTextValue(nodeName,
Constants.ClusterOptionNode);
string actionAlign = Utility._xmlUtil.GetTextValue(nodeName,
Constants.ActionAlignNode);
ClustalWParameters parameters = new ClustalWParameters();
parameters.Values[ClustalWParameters.Email] = emailId;
parameters.Values[ClustalWParameters.ClusterOption] = clusterOption;
parameters.Values[ClustalWParameters.ActionAlign] = actionAlign;
// Get the input sequences
FastaParser parser = new FastaParser();
IList <ISequence> sequence = parser.Parse(filepath);
// Submit job and cancel job
// Validate cancel job is working as expected
ConfigParameters configparams = new ConfigParameters();
ClustalWParser clustalparser = new ClustalWParser();
configparams.UseBrowserProxy = true;
TestIClustalWServiceHandler handler =
new TestIClustalWServiceHandler(clustalparser, configparams);
ServiceParameters svcparams = handler.SubmitRequest(sequence, parameters);
bool result = handler.CancelRequest(svcparams);
Assert.IsTrue(result);
Console.WriteLine(string.Concat("JobId:", svcparams.JobId));
ApplicationLog.WriteLine(string.Concat("JobId:", svcparams.JobId));
Assert.IsNotEmpty(svcparams.JobId);
foreach (string key in svcparams.Parameters.Keys)
{
Assert.IsNotEmpty(svcparams.Parameters[key].ToString());
Console.WriteLine(string.Format("{0} : {1}",
key, svcparams.Parameters[key].ToString()));
ApplicationLog.WriteLine(string.Format("{0} : {1}",
key, svcparams.Parameters[key].ToString()));
}
Console.WriteLine(
"ClustalWServiceHandler BVT : Cancel job is submitted as expected");
ApplicationLog.WriteLine(
"ClustalWServiceHandler BVT : Cancel job is submitted as expected");
}
/// <summary>
/// CreateJob() to get job id and control id and Submit job
/// using input sequence with job id and control id
/// </summary>
/// <param name="sequence">input sequences</param>
/// <param name="parameters">input params</param>
/// <returns>result params with job id and control id</returns>
public ServiceParameters SubmitRequest(IList <ISequence> sequence, ClustalWParameters parameters)
{
ServiceParameters result = new ServiceParameters();
// ClusterOption = biosim cbsum1 cbsum2k8 cbsusrv05 cbsum2 or Auto
string[] output = _baseClient.CreateJob(tAppId.P_CLUSTALW, "test_BioHPC_Job", "1", parameters.Values[ClustalWParameters.Email].ToString(),
string.Empty, parameters.Values[ClustalWParameters.ClusterOption].ToString());
if (!output[0].Contains(ERROR))
{
result.JobId = output[1];
result.Parameters.Add(CONTROLID, output[2]);
AppInputData inputData = _baseClient.InitializeApplicationParams(tAppId.P_CLUSTALW, "test_BioHPC_Job");
FastaFormatter formatter = new FastaFormatter();
StringBuilder inputSequence = new StringBuilder();
foreach (ISequence seq in sequence)
{
inputSequence.AppendLine(formatter.FormatString(seq));
}
//formatter.Format(sequence, "temp");
//StreamReader reader = new StreamReader("temp");
inputData.clustalw.inputsource = QuerySrcType.paste;
inputData.clustalw.inputstring = inputSequence.ToString();
inputData.clustalw.isDNA = false;
inputData.clustalw.action = (ClwActions)Enum.Parse(typeof(ClwActions),
parameters.Values[ClustalWParameters.ActionAlign].ToString());
inputData.clustalw.email_notify = true;
_baseClient.SubmitJob(result.JobId, result.Parameters[CONTROLID].ToString(), inputData);
result.Parameters.Add(SUBMISSONRESULT, SUCCESS);
// Only if the event is registered, invoke the thread
if (null != RequestCompleted)
{
// Start the BackGroundThread to check the status of job
_workerThread = new BackgroundWorker();
_workerThread.WorkerSupportsCancellation = true;
_workerThread.DoWork += new DoWorkEventHandler(ProcessRequestThread);
_workerThread.RunWorkerCompleted += new RunWorkerCompletedEventHandler(CompletedRequestThread);
_workerThread.RunWorkerAsync(result);
}
}
else
{
result.Parameters.Add(SUBMISSONRESULT, output[0]);
}
return(result);
}
public void OpenMappingForm(ServiceParameters serviceParameters, IWin32Window owner, List <EntityMetadata> inputCachedMetadata, Dictionary <string, Dictionary <string, List <string> > > inputLookupMaping, string inputEntityLogicalName)
{
using (var mappingDialog = new MappingListLookup(inputLookupMaping, serviceParameters.OrganizationService, inputCachedMetadata, inputEntityLogicalName, serviceParameters.MetadataService, serviceParameters.ExceptionService)
{
StartPosition = FormStartPosition.CenterParent
})
{
if (owner != null)
{
mappingDialog.ShowDialog(owner);
}
mappingDialog.RefreshMappingList();
}
}
/// <summary>
/// Validate submit job and Get Results using event handler
/// </summary>
/// <param name="nodeName">xml node name</param>
void ValidateFetchResultsUsingEvent(string nodeName)
{
// Read input from config file
string filepath = utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string emailId = utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.EmailIDNode);
string clusterOption = utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.ClusterOptionNode);
string actionAlign = utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.ActionAlignNode);
ClustalWParameters parameters = new ClustalWParameters();
parameters.Values[ClustalWParameters.Email] = emailId;
parameters.Values[ClustalWParameters.ClusterOption] = clusterOption;
parameters.Values[ClustalWParameters.ActionAlign] = actionAlign;
IEnumerable <ISequence> sequence = null;
// Get the input sequences
using (FastAParser parser = new FastAParser(filepath))
{
sequence = parser.Parse();
// Register event and submit request
ConfigParameters configparams = new ConfigParameters();
ClustalWParser clustalparser = new ClustalWParser();
configparams.UseBrowserProxy = true;
TestIClustalWServiceHandler handler =
new TestIClustalWServiceHandler(clustalparser, configparams);
handler.RequestCompleted +=
new EventHandler <ClustalWCompletedEventArgs>(handler_RequestCompleted);
ServiceParameters svcparams = handler.SubmitRequest(sequence.ToList(), parameters);
WaitHandle[] aryHandler = new WaitHandle[1];
aryHandler[0] = _resetEvent;
WaitHandle.WaitAny(aryHandler);
// Validate the submit job results
Assert.IsFalse(string.IsNullOrEmpty(svcparams.JobId));
foreach (string key in svcparams.Parameters.Keys)
{
Assert.IsFalse(string.IsNullOrEmpty(svcparams.Parameters[key].ToString()));
}
_resetEvent.Close();
_resetEvent.Dispose();
}
}
/// <summary>
/// Validate submit job and Get Results using event handler
/// </summary>
/// <param name="nodeName">xml node name</param>
void ValidateFetchResultsUsingEvent(string nodeName)
{
// Read input from config file
string filepath = Utility._xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
string emailId = Utility._xmlUtil.GetTextValue(nodeName,
Constants.EmailIDNode);
string clusterOption = Utility._xmlUtil.GetTextValue(nodeName,
Constants.ClusterOptionNode);
string actionAlign = Utility._xmlUtil.GetTextValue(nodeName,
Constants.ActionAlignNode);
ClustalWParameters parameters = new ClustalWParameters();
parameters.Values[ClustalWParameters.Email] = emailId;
parameters.Values[ClustalWParameters.ClusterOption] = clusterOption;
parameters.Values[ClustalWParameters.ActionAlign] = actionAlign;
// Get the input sequences
FastaParser parser = new FastaParser();
IList <ISequence> sequence = parser.Parse(filepath);
// Register event and submit request
ConfigParameters configparams = new ConfigParameters();
ClustalWParser clustalparser = new ClustalWParser();
configparams.UseBrowserProxy = true;
TestIClustalWServiceHandler handler =
new TestIClustalWServiceHandler(clustalparser, configparams);
handler.RequestCompleted +=
new EventHandler <ClustalWCompletedEventArgs>(handler_RequestCompleted);
ServiceParameters svcparams = handler.SubmitRequest(sequence, parameters);
WaitHandle[] aryHandler = new WaitHandle[1];
aryHandler[0] = _resetEvent;
WaitHandle.WaitAny(aryHandler);
// Validate the submit job results
Assert.IsNotEmpty(svcparams.JobId);
Console.WriteLine("JobId:" + svcparams.JobId);
foreach (string key in svcparams.Parameters.Keys)
{
Assert.IsNotEmpty(svcparams.Parameters[key].ToString());
Console.WriteLine(string.Format("{0} : {1}",
key, svcparams.Parameters[key].ToString()));
}
}
/// <summary>
/// Process the request. This method takes care of executing the rest of the steps
/// to complete the blast search request in a background thread. Which involves
/// 1. Submit the job to server
/// 2. Ping the service with the request identifier to get the status of request.
/// 3. Repeat step 1, at "RetryInterval" for "RetryCount" till a "success"/"failure"
/// status.
/// 4. If the status is a "failure" raise an completed event to notify the user
/// with appropriate details.
/// 5. If the status "success". Get the output of search from server in xml format.
/// 6. Parse the xml and the framework object model.
/// 7. Raise the completed event and notify user with the output.
/// </summary>
/// <param name="sender">Client request Azure Blast search</param>
/// <param name="e">Thread event argument</param>
private void ProcessRequestThread(object sender, DoWorkEventArgs e)
{
ServiceParameters serviceParameters = (ServiceParameters)e.Argument;
IList <ISequenceAlignment> alignments = null;
if (ERROR != serviceParameters.Parameters[SUBMISSONRESULT].ToString())
{
int retrycount = 0;
ServiceRequestInformation info;
do
{
info = GetRequestStatus(serviceParameters);
if (info.Status == ServiceRequestStatus.Ready)
{
break;
}
retrycount++;
}while (retrycount < 10);
if (_workerThread.CancellationPending)
{
e.Cancel = true;
}
else
{
ClustalWCompletedEventArgs eventArgument = null;
if (info.Status == ServiceRequestStatus.Ready)
{
string output = _baseClient.GetOutputAsString(serviceParameters.JobId, serviceParameters.Parameters["ControldId"].ToString());
using (StringReader reader = new StringReader(output))
{
alignments = _ClustalWParser.Parse(reader);
}
eventArgument = new ClustalWCompletedEventArgs(
serviceParameters,
true,
new ClustalWResult(alignments[0]),
null,
string.Empty,
_workerThread.CancellationPending);
e.Result = eventArgument;
}
}
}
}
public async Task AndIsProvider_ThenContinuesToAction(
[Frozen] ServiceParameters serviceParameters,
[ArrangeActionContext] ActionExecutingContext context,
[Frozen] Mock <ActionExecutionDelegate> nextMethod,
LevyNotPermittedFilter filter)
{
//Arrange
serviceParameters.AuthenticationType = AuthenticationType.Provider;
//Act
await filter.OnActionExecutionAsync(context, nextMethod.Object);
//Assert
nextMethod.Verify(x => x(), Times.Once);
Assert.Null(context.Result);
}
public async Task And_No_EmployerId_Then_Redirect_To_Error(
[Frozen] ServiceParameters serviceParameters,
[ArrangeActionContext] ActionExecutingContext context,
Mock <ActionExecutionDelegate> mockNext,
NonEoiNotPermittedFilterAttribute filter)
{
serviceParameters.AuthenticationType = AuthenticationType.Employer;
context.HttpContext = new DefaultHttpContext();
await filter.OnActionExecutionAsync(context, mockNext.Object);
mockNext.Verify(next => next(), Times.Never());
var result = context.Result as RedirectToRouteResult;
result.RouteName.Should().Be(RouteNames.Error500);
}
/// <summary>
/// Cancel the submitted job
/// </summary>
/// <param name="serviceParameters">job id, control id</param>
/// <returns>Job is cancelled or not</returns>
public bool CancelRequest(ServiceParameters serviceParameters)
{
if (_workerThread != null)
{
_workerThread.CancelAsync();
}
if (null == serviceParameters)
{
throw new ArgumentNullException("serviceParameters");
}
string errorresult = _baseClient.CancelJob(serviceParameters.JobId, serviceParameters.Parameters[CONTROLID].ToString());
return(errorresult.ToUpper(CultureInfo.CurrentCulture).Contains(STOPPED.ToUpper(CultureInfo.CurrentCulture)));
}
private void ServiceContextActionButton_Click(object sender, EventArgs e)
{
ServiceParameters ServiceParams = new ServiceParameters();
ServiceParams.ServiceName = SelectedService;
NetworkParameters NetParams = new NetworkParameters();
NetParams.RemoteSystemName = MachineName;
RemoteExecutionManager RemoteExec = new RemoteExecutionManager();
if (ServiceAction == ServiceActionType.StartService)
{
StartService Start = new StartService();
Start.ServiceParameters = ServiceParams;
RemoteExec.Command = Start;
RemoteExec.NetParams = NetParams;
IResult StartResult = RemoteExec.Execute();
if (StartResult.Result == ExecutionResultType.Passed)
{
MessageBox.Show(SelectedService + " has been successfully started on the remote machine " + MachineName, "Start Service", MessageBoxButtons.OK, MessageBoxIcon.Information);
RefreshServiceList();
}
else
{
MessageBox.Show("Failed to start the service " + SelectedService + " on the remote machine " + MachineName + " due to the following reason : " + StartResult.FailureException.Message, "Start Service", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
else
if (ServiceAction == ServiceActionType.StopService)
{
StopService Stop = new StopService();
Stop.ServiceParameters = ServiceParams;
RemoteExec.Command = Stop;
RemoteExec.NetParams = NetParams;
IResult StopResult = RemoteExec.Execute();
if (StopResult.Result == ExecutionResultType.Passed)
{
MessageBox.Show(SelectedService + " has been successfully stopped on the remote machine " + MachineName, "Stop Service", MessageBoxButtons.OK, MessageBoxIcon.Information);
RefreshServiceList();
}
else
{
MessageBox.Show("Failed to stop the service " + SelectedService + " on the remote machine " + MachineName + " due to the following reason : " + StopResult.FailureException.Message, "Stop Service", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
private void ManageService(string serviceName, string command, string login, string password)
{
Logger.EnteringMethod();
prgBrSearch.Value = 0;
prgBrSearch.Maximum = dtGrdVResult.SelectedRows.Count;
prgBrSearch.Refresh();
ChangeUIAccess(false);
ServiceParameters serviceParams = new ServiceParameters();
serviceParams.ServiceName = serviceName;
serviceParams.Command = command;
serviceParams.Login = login;
serviceParams.Password = password;
System.Threading.Thread t = new System.Threading.Thread(new System.Threading.ParameterizedThreadStart(StartManageService));
t.Start(serviceParams);
}
/// <summary>
/// Get the alignment results
/// </summary>
/// <param name="serviceParameters">job id, control id</param>
/// <returns>alignment</returns>
public ClustalWResult FetchResultsAsync(ServiceParameters serviceParameters)
{
IList <ISequenceAlignment> alignments = null;
if (null == serviceParameters)
{
throw new ArgumentNullException("Parameters");
}
string output = _baseClient.GetOutputAsString(serviceParameters.JobId, serviceParameters.Parameters[CONTROLID].ToString());
using (StringReader reader = new StringReader(output))
{
alignments = _ClustalWParser.Parse(reader);
}
return(new ClustalWResult(alignments[0]));
}
private void SaveAllToolStripMenuItemClick(object sender, EventArgs e)
{
var controller = new ConfigurationController();
controller.GenerateImportConfigFile(NotificationService, tbImportConfig, mapper);
controller.GenerateExportConfigFile(tbExportConfig, tbSchemaPath, filterQuery, lookupMaping, NotificationService);
var serviceParameters = new ServiceParameters(OrganizationService, MetadataService, NotificationService, ExceptionService);
var entityController = new EntityController();
entityController.CollectCrmEntityFields(checkedEntity, crmSchemaConfiguration, entityRelationships, entityAttributes, attributeMapping, serviceParameters);
var schemaController = new SchemaController();
schemaController.GenerateXMLFile(tbSchemaPath, crmSchemaConfiguration);
crmSchemaConfiguration.Entities.Clear();
}
public async Task And_Employer_Is_Non_Levy_And_Not_EOI_Then_Show_EOI_Holding_View(
[ArrangeActionContext] ActionExecutingContext context,
string employerAccountId,
long decodedEmployerAccountId,
string homeUrl,
GetLegalEntitiesResponse legalEntitiesResponse,
Mock <ActionExecutionDelegate> mockNext,
[Frozen] ServiceParameters serviceParameters,
[Frozen] Mock <IEncodingService> mockEncodingService,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IExternalUrlHelper> mockUrlHelper,
NonEoiNotPermittedFilterAttribute filter)
{
serviceParameters.AuthenticationType = AuthenticationType.Employer;
context.HttpContext = new DefaultHttpContext();
context.RouteData.Values.Add("employerAccountId", employerAccountId);
foreach (var accountLegalEntity in legalEntitiesResponse.AccountLegalEntities)
{
accountLegalEntity.IsLevy = false;
accountLegalEntity.AgreementType = AgreementType.Levy;
}
mockEncodingService
.Setup(service => service.Decode(
context.RouteData.Values["employerAccountId"].ToString(),
EncodingType.AccountId))
.Returns(decodedEmployerAccountId);
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetLegalEntitiesQuery>(query => query.AccountId == decodedEmployerAccountId),
It.IsAny <CancellationToken>()))
.ReturnsAsync(legalEntitiesResponse);
mockUrlHelper
.Setup(helper => helper.GenerateDashboardUrl(employerAccountId))
.Returns(homeUrl);
await filter.OnActionExecutionAsync(context, mockNext.Object);
mockNext.Verify(next => next(), Times.Never());
var result = context.Result as ViewResult;
result.ViewName.Should().Be("NonEoiHolding");
var model = result.Model as NonEoiHoldingViewModel;
model.HomeLink.Should().Be(homeUrl);
}
/// <summary>
/// Cancel the submitted job
/// </summary>
/// <param name="serviceParameters">job id, control id</param>
/// <returns>Job is cancelled or not</returns>
public bool CancelRequest(ServiceParameters serviceParameters)
{
if (_workerThread != null)
{
_workerThread.CancelAsync();
}
string errorresult = _baseClient.CancelJob(serviceParameters.JobId, serviceParameters.Parameters[CONTROLID].ToString());
Console.WriteLine(errorresult);
if (errorresult.ToUpper(CultureInfo.CurrentCulture).Contains(STOPPED.ToUpper(CultureInfo.CurrentCulture)))
{
return(true);
}
else
{
return(false);
}
}
public async Task And_Employer_Is_Non_Levy_And_Not_EOI_And_Has_TransferSenderId_In_Request_Then_Continues_To_Select_Action(
[Frozen] ServiceParameters serviceParameters,
[ArrangeActionContext] ActionExecutingContext context,
Mock <ActionExecutionDelegate> mockNext,
NonEoiNotPermittedFilterAttribute filter)
{
serviceParameters.AuthenticationType = AuthenticationType.Employer;
context.HttpContext = new DefaultHttpContext();
context.HttpContext.Request.Path = PathString.FromUriComponent(new Uri("https://test.com/selectreservation/selectreservation"));
context.HttpContext.Request.Query = new QueryCollection(new Dictionary <string, StringValues> {
{ "transferSenderId", "123RED" }
});
context.RouteData.Values.Add("controller", "SelectReservations");
context.RouteData.Values.Add("action", "SelectReservation");
await filter.OnActionExecutionAsync(context, mockNext.Object);
mockNext.Verify(next => next(), Times.Once);
context.Result.Should().Be(null);
}
/// <summary>
/// Get the status of job using job id and control id after submitting the job
/// </summary>
/// <param name="parameters">job id, control id</param>
/// <returns>result with status of job</returns>
public MBF.Web.ServiceRequestInformation GetRequestStatus(ServiceParameters parameters)
{
string jobStatus = _baseClient.GetJobInfo(parameters.JobId, parameters.Parameters[CONTROLID].ToString());
string[] statusArray = jobStatus.Split('|');
ServiceRequestInformation info = new ServiceRequestInformation();
switch (statusArray[6])
{
case "FINISHED":
info.Status = ServiceRequestStatus.Ready;
break;
case "ERROR":
info.Status = ServiceRequestStatus.Error;
break;
default:
break;
}
return(info);
}
public async Task Then_If_Provider_Adds_The_ProviderId_To_The_ViewBag_Data(
uint ukprn,
[Frozen] ServiceParameters serviceParameters,
[ArrangeActionContext] ActionExecutingContext context,
[Frozen] Mock <ActionExecutionDelegate> nextMethod,
GoogleAnalyticsFilter filter)
{
//Arrange
context.RouteData.Values.Add("ukPrn", ukprn);
serviceParameters.AuthenticationType = AuthenticationType.Provider;
//Act
await filter.OnActionExecutionAsync(context, nextMethod.Object);
//Assert
var actualController = context.Controller as Controller;
Assert.IsNotNull(actualController);
var viewBagData = actualController.ViewBag.GaData as GaData;
Assert.IsNotNull(viewBagData);
Assert.AreEqual(ukprn.ToString(), viewBagData.UkPrn);
}
public async Task And_Employer_Is_Non_Levy_And_Is_EOI_Then_Executes_Action(
[ArrangeActionContext] ActionExecutingContext context,
string employerAccountId,
long decodedEmployerAccountId,
GetLegalEntitiesResponse legalEntitiesResponse,
Mock <ActionExecutionDelegate> mockNext,
[Frozen] ServiceParameters serviceParameters,
[Frozen] Mock <IEncodingService> mockEncodingService,
[Frozen] Mock <IMediator> mockMediator,
NonEoiNotPermittedFilterAttribute filter)
{
context.Result = null;
context.HttpContext = new DefaultHttpContext();
serviceParameters.AuthenticationType = AuthenticationType.Employer;
context.RouteData.Values.Add("employerAccountId", employerAccountId);
foreach (var accountLegalEntity in legalEntitiesResponse.AccountLegalEntities)
{
accountLegalEntity.IsLevy = false;
accountLegalEntity.AgreementType = AgreementType.NonLevyExpressionOfInterest;
}
mockEncodingService
.Setup(service => service.Decode(
context.RouteData.Values["employerAccountId"].ToString(),
EncodingType.AccountId))
.Returns(decodedEmployerAccountId);
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetLegalEntitiesQuery>(query => query.AccountId == decodedEmployerAccountId),
It.IsAny <CancellationToken>()))
.ReturnsAsync(legalEntitiesResponse);
await filter.OnActionExecutionAsync(context, mockNext.Object);
mockNext.Verify(next => next(), Times.Once);
context.Result.Should().Be(null);
}
public async Task Then_If_User_Is_Not_Logged_In_Then_Empty_ViewBag_Data_Is_Returned(
long accountId,
[Frozen] ServiceParameters serviceParameters,
[ArrangeActionContext] ActionExecutingContext context,
[Frozen] Mock <ActionExecutionDelegate> nextMethod,
GoogleAnalyticsFilter filter)
{
//Arrange
context.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity());
serviceParameters.AuthenticationType = AuthenticationType.Employer;
//Act
await filter.OnActionExecutionAsync(context, nextMethod.Object);
//Assert
var actualController = context.Controller as Controller;
Assert.IsNotNull(actualController);
var viewBagData = actualController.ViewBag.GaData as GaData;
Assert.IsNotNull(viewBagData);
Assert.IsNull(viewBagData.Acc);
Assert.IsNull(viewBagData.UserId);
}
public async Task AndIsALevyEmployer_ThenRedirectsToAccessDeniedPage(
[Frozen] ServiceParameters serviceParameters,
[Frozen] Mock <IMediator> mockMediator,
GetLegalEntitiesResponse legalEntitiesResponse,
IEnumerable <AccountLegalEntity> legalEntities,
string employerAccountId,
long decodedId,
[Frozen] Mock <IEncodingService> mockEncodingService,
[ArrangeActionContext] ActionExecutingContext context,
[Frozen] Mock <ActionExecutionDelegate> nextMethod,
LevyNotPermittedFilter filter)
{
//Arrange
serviceParameters.AuthenticationType = AuthenticationType.Employer;
legalEntitiesResponse.AccountLegalEntities = legalEntities;
context.RouteData.Values.Add("employerAccountId", employerAccountId);
foreach (var legalEntity in legalEntitiesResponse.AccountLegalEntities)
{
legalEntity.IsLevy = true;
}
mockEncodingService
.Setup(x => x.TryDecode(employerAccountId, EncodingType.AccountId, out decodedId))
.Returns(true);
mockMediator
.Setup(x => x.Send(It.Is <GetLegalEntitiesQuery>(y => y.AccountId == decodedId), It.IsAny <CancellationToken>()))
.ReturnsAsync(legalEntitiesResponse);
//Act
await filter.OnActionExecutionAsync(context, nextMethod.Object);
//Assert
Assert.NotNull(context.Result);
Assert.True(context.Result is RedirectToRouteResult);
Assert.AreEqual((context.Result as RedirectToRouteResult).RouteName, RouteNames.Error403);
nextMethod.Verify(x => x(), Times.Never);
}
private void ChangeServiceState(object parameters)
{
ServiceParameters serviceParams = (ServiceParameters)parameters;
object[] args = new object[3];
args[0] = resMan.GetString("FailedToSendCommand");
args[1] = serviceParams.RowIndex;
args[2] = "ServiceStatus";
if (!_closing && !_aborting && !_wrongCrendentialsWatcher.IsAbortRequested)
{
lock (_ChangeServiceStateLocker)
{
try
{
if (!_closing && !_aborting && !_wrongCrendentialsWatcher.IsAbortRequested)
{
ADComputer computer = new ADComputer(dtGrdVResult.Rows[serviceParams.RowIndex].Cells["ComputerName"].Value.ToString());
bool result = false;
if (serviceParams.Command == "RestartService")
{
computer.ManageService(serviceParams.ServiceName, "StopService", serviceParams.Login, serviceParams.Password);
result = computer.ManageService(serviceParams.ServiceName, "StartService", serviceParams.Login, serviceParams.Password);
args[0] = result ? resMan.GetString("Running") : resMan.GetString("Failed");
}
else
{
result = computer.ManageService(serviceParams.ServiceName, serviceParams.Command, serviceParams.Login, serviceParams.Password);
args[0] = result ? ((serviceParams.Command == "StartService") ? resMan.GetString("Running") : resMan.GetString("Stopped")) : resMan.GetString("Failed");
}
}
else
{
args[0] = resMan.GetString("Aborted");
}
}
catch (UnauthorizedAccessException)
{
_wrongCrendentialsWatcher.IsWrongCredentials = true;
if (!_wrongCrendentialsWatcher.ContinueWithFailedCredentials)
{
if (MessageBox.Show(resMan.GetString("CredentialFailed"), resMan.GetString("FailedToConnect"), MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.No)
{
Logger.Write("interrupt on failed credentials.");
_wrongCrendentialsWatcher.IsAbortRequested = true;
args[0] = resMan.GetString("Aborted");
}
else
{
Logger.Write("Continue with bad credentials.");
_wrongCrendentialsWatcher.ContinueWithFailedCredentials = true;
args[0] = resMan.GetString("FailedToConnect");
}
}
else
{
args[0] = resMan.GetString("FailedToConnect");
}
}
catch (Exception ex)
{
Logger.Write(ex.Message);
args[0] = resMan.GetString("FailedToSendCommand");
}
}
}
else
{
args[0] = resMan.GetString("Aborted");
}
UpdateRow(args);
}
/// <summary>
/// Validate Submit Job and Fetch ResultSync() using multiple input sequences
/// </summary>
/// <param name="nodeName">xml node name</param>
void ValidateFetchResultSync(string nodeName)
{
// Read input from config file
string filepath = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.FilePathNode);
string emailId = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.EmailIDNode);
string clusterOption = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ClusterOptionNode);
string actionAlign = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.ActionAlignNode);
// Initialize with parser and config params
ConfigParameters configparams = new ConfigParameters();
ClustalWParser clustalparser = new ClustalWParser();
configparams.UseBrowserProxy = true;
TestIClustalWServiceHandler handler =
new TestIClustalWServiceHandler(clustalparser, configparams);
ClustalWParameters parameters = new ClustalWParameters();
parameters.Values[ClustalWParameters.Email] = emailId;
parameters.Values[ClustalWParameters.ClusterOption] = clusterOption;
parameters.Values[ClustalWParameters.ActionAlign] = actionAlign;
IEnumerable <ISequence> sequence = null;
// Get the input sequences
using (FastAParser parser = new FastAParser(filepath))
{
sequence = parser.Parse();
// Submit job and validate it returned valid job id and control id
ServiceParameters svcparameters =
handler.SubmitRequest(sequence.ToList(), parameters);
Assert.IsFalse(string.IsNullOrEmpty(svcparameters.JobId));
Console.WriteLine(string.Concat("JobId", svcparameters.JobId));
ApplicationLog.WriteLine(string.Concat("JobId", svcparameters.JobId));
foreach (string key in svcparameters.Parameters.Keys)
{
Assert.IsFalse(string.IsNullOrEmpty(svcparameters.Parameters[key].ToString()));
Console.WriteLine(string.Format((IFormatProvider)null, "{0}:{1}",
key, svcparameters.Parameters[key].ToString()));
ApplicationLog.WriteLine(string.Format((IFormatProvider)null, "{0}:{1}",
key, svcparameters.Parameters[key].ToString()));
}
// Get the results and validate it is not null.
ClustalWResult result = handler.FetchResultsSync(svcparameters);
Assert.IsNotNull(result);
Assert.IsNotNull(result.SequenceAlignment);
foreach (IAlignedSequence alignSeq in result.SequenceAlignment.AlignedSequences)
{
Console.WriteLine("Aligned Sequence Sequences :");
ApplicationLog.WriteLine("Aligned Sequence Sequences :");
foreach (ISequence seq in alignSeq.Sequences)
{
Console.WriteLine(string.Concat("Sequence:", seq.ToString()));
ApplicationLog.WriteLine(string.Concat("Sequence:", seq.ToString()));
}
}
}
Console.WriteLine(@"ClustalWServiceHandler BVT : Submit job and Get Results is successfully completed using FetchResultSync()");
ApplicationLog.WriteLine(@"ClustalWServiceHandler BVT : Submit job and Get Results is successfully completed using FetchResultSync()");
}
/// <summary>
/// Validate submit job and FetchResultAsync() using multiple input sequences
/// </summary>
/// <param name="nodeName">xml node name</param>
void ValidateFetchResultAsync(string nodeName)
{
// Read input from config file
string filepath = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.FilePathNode);
string emailId = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.EmailIDNode);
string clusterOption = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.ClusterOptionNode);
string actionAlign = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.ActionAlignNode);
ConfigParameters configparams = new ConfigParameters();
ClustalWParser clustalparser = new ClustalWParser();
configparams.UseBrowserProxy = true;
TestIClustalWServiceHandler handler =
new TestIClustalWServiceHandler(clustalparser, configparams);
ClustalWParameters parameters = new ClustalWParameters();
parameters.Values[ClustalWParameters.Email] = emailId;
parameters.Values[ClustalWParameters.ClusterOption] = clusterOption;
parameters.Values[ClustalWParameters.ActionAlign] = actionAlign;
IList <ISequence> sequence = null;
// Get input sequences
using (FastaParser parser = new FastaParser())
{
sequence = parser.Parse(filepath);
}
// Submit job and validate it returned valid job id and control id
ServiceParameters svcparameters = handler.SubmitRequest(sequence, parameters);
Assert.IsTrue(string.IsNullOrEmpty(svcparameters.JobId));
Console.WriteLine(string.Concat("JobId:", svcparameters.JobId));
foreach (string key in svcparameters.Parameters.Keys)
{
Assert.IsTrue(string.IsNullOrEmpty(svcparameters.Parameters[key].ToString()));
Console.WriteLine(string.Format((IFormatProvider)null, "{0}:{1}",
key, svcparameters.Parameters[key].ToString()));
}
// Get the results and validate it is not null.
ClustalWResult result = null;
int retrycount = 0;
ServiceRequestInformation info;
do
{
info = handler.GetRequestStatus(svcparameters);
if (info.Status == ServiceRequestStatus.Ready)
{
break;
}
Thread.Sleep(
info.Status == ServiceRequestStatus.Waiting ||
info.Status == ServiceRequestStatus.Queued ?
Constants.ClusterRetryInterval * retrycount : 0);
retrycount++;
}while (retrycount < 10);
if (info.Status == ServiceRequestStatus.Ready)
{
result = handler.FetchResultsAsync(svcparameters);
}
Assert.IsNotNull(result);
Assert.IsNotNull(result.SequenceAlignment);
foreach (IAlignedSequence alignSeq in result.SequenceAlignment.AlignedSequences)
{
Console.WriteLine("Aligned Sequence Sequences : ");
ApplicationLog.WriteLine("Aligned Sequence Sequences : ");
foreach (ISequence seq in alignSeq.Sequences)
{
Console.WriteLine(string.Concat("Sequence:", seq.ToString()));
ApplicationLog.WriteLine(string.Concat("Sequence:", seq.ToString()));
}
}
Console.WriteLine(@"ClustalWServiceHandler BVT : Submit job and Get Results is
successfully completed using FetchResultAsync()");
ApplicationLog.WriteLine(@"ClustalWServiceHandler BVT : Submit job and Get Results
is successfully completed using FetchResultAsync()");
}
private static void StartServiceBackround(object parameters)
{
ServiceParameters param = (ServiceParameters)parameters;
StartService(param.serviceName, param.timeout);
}
/// <summary>
/// Initializes a new instance of the ClustalWThreadContext class.
/// </summary>
/// <param name="parameters">ClustalW Service</param>
public ClustalWThreadContext(
ServiceParameters parameters)
{
_parameters = parameters;
}
public GoogleAnalyticsFilter(ServiceParameters serviceParameters)
{
_serviceParameters = serviceParameters;
}
