/// <summary>
/// Submit the search request with the user supplied configuration parameters and sequence
/// Implementation should make use of the Bio.IO formatters to convert the sequence into
/// the web interface compliant sequence format
/// </summary>
/// <remarks>An exception is thrown if the request does not succeed.</remarks>
/// <param name="sequences">List of sequence to search with</param>
/// <param name="parameters">Blast input parameters</param>
/// <returns>Request Identifier</returns>
public string SubmitRequest(IList <ISequence> sequences, BlastParameters parameters)
{
if (null == parameters)
{
throw new ArgumentNullException("parameters");
}
if (null != sequences)
{
StringBuilder sb = new StringBuilder();
foreach (ISequence seq in sequences)
{
sb.Append(FastAFormatter.FormatString(seq));
sb.Append("\n");
}
parameters.Add("Query", sb.ToString());
}
if (!string.IsNullOrEmpty(Configuration.EmailAddress))
{
if (!parameters.Settings.ContainsKey(PARAMETEREMAIL))
{
parameters.Add(PARAMETEREMAIL, Configuration.EmailAddress);
}
}
string requestIdentifier = string.Empty;
// Validate the Parameter
ParameterValidationResult valid = ValidateParameters(parameters);
if (!valid.IsValid)
{
throw new Exception(valid.ValidationErrors);
}
parameters.Add(PARAMETERCOMMAND, COMMANDPUT);
WebAccessor accessor = new WebAccessor();
WebAccessorResponse webAccessorResponse;
if (Configuration.UseBrowserProxy)
{
accessor.GetBrowserProxy();
}
webAccessorResponse = accessor.SubmitHttpRequest(
ServiceUri,
true, // do POST
parameters.Settings); // request parameters
if (!webAccessorResponse.IsSuccessful)
{
// failed
accessor.Close();
throw new Exception(String.Format(CultureInfo.InvariantCulture,
Resources.HTTPSUBMITFAILED,
webAccessorResponse.StatusDescription));
}
string info = ExtractInfoSection(webAccessorResponse.ResponseString);
if (!String.IsNullOrEmpty(info))
{
int ridStart = info.IndexOf("RID = ", StringComparison.OrdinalIgnoreCase);
if (ridStart >= 0)
{
ridStart += "RID = ".Length;
int ridEnd = info.IndexOf('\n', ridStart);
if (ridEnd >= 0)
{
requestIdentifier = info.Substring(ridStart, ridEnd - ridStart);
}
}
}
accessor.Close();
if (string.IsNullOrEmpty(requestIdentifier))
{
string message = String.Format(CultureInfo.InvariantCulture,
Resources.RIDEXTRACTFAILED,
ExtractError(webAccessorResponse.ResponseString));
throw new Exception(message);
}
// Only if the event is registered, invoke the thread
if (null != RequestCompleted)
{
BlastThreadParameter threadParameter = new BlastThreadParameter(
requestIdentifier,
null, // Sequence parameter is not used any where, hence passing null.
parameters);
// 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(threadParameter);
}
return(requestIdentifier);
}
/// <summary>
/// Check the currently set parameters for validity
/// </summary>
/// <param name="parameters">Blast input parameters</param>
/// <returns>Validation result</returns>
private static ParameterValidationResult ValidateParameters(BlastParameters parameters)
{
ParameterValidationResult result = new ParameterValidationResult();
result.IsValid = true;
// check required parameters:
if (!parameters.Settings.ContainsKey(PARAMETERDATABASE))
{
result.IsValid = false;
result.ValidationErrors += Resources.PARAMETERDATABASEREQUIRED;
}
if (!parameters.Settings.ContainsKey(PARAMETERPROGRAM))
{
result.IsValid = false;
result.ValidationErrors += Resources.PARAMETERPROGRAMREQUIRED;
}
else
{
// force program to lowercase (NCBI QBlast does require this)
parameters.Settings[PARAMETERPROGRAM] =
parameters.Settings[PARAMETERPROGRAM].ToLowerInvariant();
}
// verify that we have a valid query
if (parameters.Settings.ContainsKey(PARAMETERQUERY))
{
if (string.IsNullOrEmpty(parameters.Settings[PARAMETERQUERY]))
{
result.IsValid = false;
result.ValidationErrors += Resources.PARAMETERSEQUENCEEMPTY;
}
}
else
{
result.IsValid = false;
result.ValidationErrors += Resources.PARAMETERSEQUENCEREQUIRED;
}
// apply any addition validation logic to the set of parameters:
// validate filters here, since EBI BLAST uses a different set:
if (parameters.Settings.ContainsKey(PARAMETERFILTER))
{
string filter = parameters.Settings[PARAMETERFILTER];
if (!Helper.StringHasMatch(filter, "T", "F", "m", "L", "R", "S", "D"))
{
result.IsValid = false;
result.ValidationErrors += string.Format(CultureInfo.InvariantCulture,
Resources.INVALIDBLASTFILTER,
filter,
"'T', 'F', 'm', 'L', 'R', 'S', 'D'");
}
}
if (parameters.Settings.ContainsKey(PARAMETERGENETICCODE))
{
int geneticCode = int.Parse(parameters.Settings[PARAMETERGENETICCODE], CultureInfo.InvariantCulture);
if (geneticCode < 1 || geneticCode > 22 ||
(geneticCode > 16 && geneticCode < 21))
{
result.IsValid = false;
result.ValidationErrors += Resources.INVALIDGENETICCODE;
}
}
int queryFrom = 0;
if (parameters.Settings.ContainsKey(PARAMETERQUERYFROM))
{
if (!int.TryParse(parameters.Settings[PARAMETERQUERYFROM], out queryFrom))
{
result.IsValid = false;
}
}
int queryTo = 0;
if (parameters.Settings.ContainsKey(PARAMETERQUERYTO))
{
if (!int.TryParse(parameters.Settings[PARAMETERQUERYTO], out queryTo))
{
result.IsValid = false;
}
}
if (((queryFrom == queryTo) && (queryFrom != 0)) ||
(queryFrom > queryTo))
{
result.IsValid = false;
result.ValidationErrors += Resources.PARAMETERQUERYTOINVALID;
}
// check disallowed parameters:
foreach (KeyValuePair <string, string> parameter in parameters.Settings)
{
switch (parameter.Key)
{
case PARAMETERCMD:
case PARAMETERRID:
case PARAMETEREMAIL:
case PARAMETERSTRAND:
case PARAMETERSENSITIVITY:
case PARAMETERFORMATTYPE:
result.IsValid = false;
result.ValidationErrors += string.Format(CultureInfo.InvariantCulture,
Resources.PARAMETERUNKNOWNNCBI,
parameter.Key);
break;
default:
break;
}
}
return(result);
}
/// <summary>
/// Check the currently set parameters for validity
/// </summary>
/// <param name="parameters">Blast input parameters</param>
/// <param name="pars">BLAST parameters in the BioHPC service format</param>
/// <returns>Validation result</returns>
private ParameterValidationResult ValidateParameters(BlastParameters parameters, AppInputData pars)
{
ParameterValidationResult result = new ParameterValidationResult();
result.IsValid = true;
// Make sure e-mail address is configured
if (string.IsNullOrEmpty(Configuration.EmailAddress))
{
result.IsValid = false;
result.ValidationErrors += Resources.PARAMETEREMAILREQUIRED;
}
// check required BLAST parameters
if (!parameters.Settings.ContainsKey(PARAMETERPROGRAM))
{
result.IsValid = false;
result.ValidationErrors += Resources.PARAMETERPROGRAMREQUIRED;
}
else
{
string prgm = parameters.Settings[PARAMETERPROGRAM].ToLower(CultureInfo.InvariantCulture);
if (Helper.StringHasMatch(prgm, Enum.GetNames(typeof(BLASTprogram))))
{
pars.blast.program = (BLASTprogram)Enum.Parse(typeof(BLASTprogram), prgm);
}
else
{
result.IsValid = false;
result.ValidationErrors += Resources.PARAMETERPROGRAMREQUIRED;
}
}
if (!parameters.Settings.ContainsKey(PARAMETERDATABASE))
{
result.IsValid = false;
result.ValidationErrors += Resources.PARAMETERDATABASEREQUIRED;
}
else
{
string dbname = parameters.Settings[PARAMETERDATABASE];
if (IsProgramDna(pars.blast.program))
{
if (IsDbstringDNA(dbname))
{
pars.blast.database.database = dbname;
}
else
{
result.IsValid = false;
result.ValidationErrors += Resources.BIOHPCNODNADB;
}
}
else
{
if (IsDbstringProt(dbname))
{
pars.blast.database.database = dbname;
}
else
{
result.IsValid = false;
result.ValidationErrors += Resources.BIOHPCNOPROTDB;
}
}
}
// Allowed parameters
if (parameters.Settings.ContainsKey(PARAMETERFILTER))
{
// If the supplied filter parameter makes sense, use it; otherwise the default will be used.
string fltr = parameters.Settings[PARAMETERFILTER];
if (Helper.StringHasMatch(fltr, Enum.GetNames(typeof(LowCompFilter))))
{
pars.blast.options.lcompfilter = (LowCompFilter)Enum.Parse(typeof(LowCompFilter), fltr);
}
}
if (parameters.Settings.ContainsKey(PARAMETERALIGNMENTS))
{
pars.blast.options.maxtargets = int.Parse(parameters.Settings[PARAMETERALIGNMENTS], CultureInfo.InvariantCulture);
}
if (parameters.Settings.ContainsKey(PARAMETERMATRIXNAME))
{
// If the supplied matrix parameter makes sense, use it; otherwise the default will be used.
string mtrx = parameters.Settings[PARAMETERMATRIXNAME].ToUpper(CultureInfo.InvariantCulture);
if (Helper.StringHasMatch(mtrx, Enum.GetNames(typeof(Bio.Web.BioHPC.Matrix))))
{
pars.blast.options.matrix = (Bio.Web.BioHPC.Matrix)Enum.Parse(typeof(Bio.Web.BioHPC.Matrix), mtrx);
}
}
if (parameters.Settings.ContainsKey(PARAMETEREXPECT))
{
pars.blast.options.ecut = double.Parse(parameters.Settings[PARAMETEREXPECT], CultureInfo.InvariantCulture);
}
if (parameters.Settings.ContainsKey(PARAMETERMINQUERYLENGTH))
{
pars.blast.options.minquerylength = int.Parse(parameters.Settings[PARAMETERMINQUERYLENGTH], CultureInfo.InvariantCulture);
}
if (parameters.Settings.ContainsKey(PARAMETEREMAILNOTIFY))
{
pars.blast.runparams.email_notify = parameters.Settings[PARAMETEREMAILNOTIFY] == "yes";
}
// Any other unknown parameters
foreach (KeyValuePair <string, string> parameter in parameters.Settings)
{
switch (parameter.Key)
{
// These are either handled above, or allowed
case PARAMETERDATABASE:
case PARAMETERPROGRAM:
case PARAMETERFORMATTYPE:
case PARAMETERFILTER:
case PARAMETERALIGNMENTS:
case PARAMETERMATRIXNAME:
case PARAMETEREXPECT:
case PARAMETERMINQUERYLENGTH:
case PARAMETEREMAILNOTIFY:
case PARAMETERJOBNAME:
case PARAMETEREMAIL:
// Allow PARAMETEREMAIL so that if Configuration.EmailAddress is empty
// then this parameter can be set to Configuration.EmailAddress
break;
default:
result.IsValid = false;
result.ValidationErrors += string.Format(
CultureInfo.InvariantCulture,
Resources.PARAMETRUNKNOWNBIOHPC,
parameter.Key);
break;
}
}
if (result.IsValid)
{
result.ParametersObject = pars;
}
return(result);
}
/// <summary>
/// Check the currently set parameters for validity
/// </summary>
/// <param name="parameters">Blast input parameters</param>
/// <returns>Validation result</returns>
private ParameterValidationResult ValidateParameters(BlastParameters parameters)
{
ParameterValidationResult result = new ParameterValidationResult();
result.IsValid = true;
// check required parameters:
if (!parameters.Settings.ContainsKey(PARAMETERDATABASE))
{
result.IsValid = false;
result.ValidationErrors += Resource.PARAMETERDATABASEREQUIRED;
}
if (!parameters.Settings.ContainsKey(PARAMETERPROGRAM))
{
result.IsValid = false;
result.ValidationErrors += Resource.PARAMETERPROGRAMREQUIRED;
}
// note: query is not part of the inputParams class, so the caller will
// need to handle it separately.
if (!parameters.Settings.ContainsKey(PARAMETEREMAIL))
{
result.IsValid = false;
result.ValidationErrors += Resource.PARAMETEREMAILREQUIRED;
}
if (parameters.Settings.ContainsKey(PARAMETERFILTER))
{
string filter = parameters.Settings[PARAMETERFILTER];
if (!Helper.StringHasMatch(filter, "none", "seg", "xnu", "seg+xnu", "dust"))
{
result.IsValid = false;
result.ValidationErrors += string.Format(Resource.INVALIDBLASTFILTER, filter);
}
}
// Any other unknown parameters
foreach (KeyValuePair <string, string> parameter in parameters.Settings)
{
switch (parameter.Key)
{
case PARAMETERDATABASE:
case PARAMETERPROGRAM:
case PARAMETEREMAIL:
case PARAMETERFILTER:
case PARAMETERALIGNMENTS:
case PARAMETERMATRIXNAME:
case PARAMETEREXPECT:
// These are valid parameter, so allow them.
break;
default:
result.IsValid = false;
result.ValidationErrors += string.Format(
Resource.PARAMETERUNKNOWNEBIWU,
parameter.Key);
break;
}
}
return(result);
}
/// <summary>
/// Submit the search request with the user supplied configuration parameters and sequence list.
/// Implementation should make use of the Bio.IO formatters to convert the sequence into
/// the web interface compliant sequence format
/// </summary>
/// <remarks>An exception is thrown if the request does not succeed.</remarks>
/// <param name="sequences">List of sequence to search with</param>
/// <param name="parameters">Blast input parameters</param>
/// <returns>Unique Search ID generated by Bio</returns>
public string SubmitRequest(IList <ISequence> sequences, BlastParameters parameters)
{
if (sequences == null)
{
throw new Exception(Resources.BIOHPCNOSEQUENCE);
}
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
string requestIdentifier;
// Start of BioHPC-specific code
// we are submitting BLAST and give the job a name
tAppId appID = tAppId.P_BLAST;
string jobname = BlastParameters.Parameters["JobName"].DefaultValue;
if (parameters.Settings.ContainsKey(PARAMETERJOBNAME))
{
if (!String.IsNullOrEmpty(parameters.Settings[PARAMETERJOBNAME]))
{
jobname = parameters.Settings[PARAMETERJOBNAME];
}
}
if (parameters.Settings.ContainsKey(PARAMETEREMAIL))
{
if (string.IsNullOrEmpty(Configuration.EmailAddress))
{
Configuration.EmailAddress = parameters.Settings[PARAMETEREMAIL];
}
}
// initialize input parameters with defaults
AppInputData pars = blastClient.InitializeApplicationParams(appID, jobname);
// Retrieve database names for easy access by parameter validator
dnaDatabases = GetServiceMetadata(MetadataDatabasesDna);
protDatabases = GetServiceMetadata(MetadataDatabasesProt);
// Validate the parameter
ParameterValidationResult valid = ValidateParameters(parameters, pars);
if (!valid.IsValid)
{
throw new Exception(valid.ValidationErrors);
}
// ValidateParameters updated some of the entries in pars and put them
// into its ParametersObject - we need to fetch the updated pars
pars = valid.ParametersObject as AppInputData;
// Set some remaining parameters...
pars.blast.querysource = QuerySrcType.paste;
// We request XML as format, since this is what we can parse...
pars.blast.options.format = OutputFormat.XML;
// Query sequence should be in full Fasta format.
// We concatenate all the sequences from the list into a single string.
pars.blast.query = String.Empty;
foreach (ISequence auxseq in sequences)
{
pars.blast.query += FastAFormatter.FormatString(auxseq) + "\n";
}
pars.blast.query = pars.blast.query.Substring(0, pars.blast.query.Length - 1); // remobe trailing newline...
// Run parameters and query string are ready. Submit the job to server:
// Create a new BLAST job.
string jobid = String.Empty;
string cntrl = String.Empty;
try
{
string[] outtab = blastClient.CreateJob(appID, jobname, "1", Configuration.EmailAddress, Configuration.Password, "Auto");
if (outtab[0].IndexOf(MsgError, StringComparison.Ordinal) != -1)
{
throw new Exception(String.Format(CultureInfo.InvariantCulture, Resources.BIOHPCJOBNOTCREATED, outtab[0]));
}
jobid = outtab[1];
cntrl = outtab[2];
requestIdentifier = jobid + "_" + cntrl;
}
catch
{
throw new Exception(Resources.BIOHPCSERVERABSENT);
}
// Finally, we can submit the job
try
{
string result = blastClient.SubmitJob(jobid, cntrl, pars);
if (result.IndexOf(MsgError, StringComparison.Ordinal) != -1)
{
throw new Exception(String.Format(CultureInfo.InvariantCulture, Resources.BIOHPCJOBNOTSUBMITTED, jobid, result));
}
}
catch
{
throw new Exception(Resources.BIOHPCSERVERABSENT);
}
// end of BioHPC-specific code
// Only if the event is registered, invoke the thread
if (null != RequestCompleted)
{
// ThreadParameter wants a single sequence - nor sure what this is for.
// We'll give it the first sequence from the list, i.e., sequence[0]
BlastThreadParameter threadParameter = new BlastThreadParameter(
requestIdentifier,
sequences[0],
parameters);
// 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(threadParameter);
}
return(requestIdentifier);
}
/// <summary>
/// Check the currently set parameters for validity
/// </summary>
/// <param name="parameters">Blast input parameters</param>
/// <returns>Validation result</returns>
public static ParameterValidationResult ValidateParameters(BlastParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
ParameterValidationResult result = new ParameterValidationResult();
result.IsValid = true;
// check required parameters:
if (!parameters.Settings.ContainsKey(ParameterDatabase))
{
result.IsValid = false;
result.ValidationErrors += Resources.PARAMETERDATABASEREQUIRED;
}
if (!parameters.Settings.ContainsKey(ParameterProgram))
{
result.IsValid = false;
result.ValidationErrors += Resources.PARAMETERPROGRAMREQUIRED;
}
if (!parameters.Settings.ContainsKey(ParameterSequenceType))
{
result.IsValid = false;
result.ValidationErrors += Resources.PARAMETERSEQUENCETYPEREQUIRED;
}
//// note: query is not part of the inputParams class, so the caller will
//// need to handle it separately.
//if (!parameters.Settings.ContainsKey(ParameterEmail))
//{
// result.IsValid = false;
// result.ValidationErrors += Resources.PARAMETEREMAILREQUIRED;
//}
if (parameters.Settings.ContainsKey(ParameterFilter))
{
string filter = parameters.Settings[ParameterFilter];
if (!Helper.StringHasMatch(filter, "none", "seg", "xnu", "seg+xnu", "dust"))
{
result.IsValid = false;
result.ValidationErrors += string.Format(CultureInfo.InvariantCulture, Resources.INVALIDBLASTFILTER, filter, "'none, 'seg', 'xnu', 'seg+xnu', 'dust'");
}
}
// Any other unknown parameters
foreach (KeyValuePair <string, string> parameter in parameters.Settings)
{
switch (parameter.Key)
{
case ParameterDatabase:
case ParameterProgram:
case ParameterSequenceType:
case ParameterEmail:
case ParameterFilter:
case ParameterAlignments:
case ParameterMatrixName:
case ParameterExpect:
case ParameterAlignmentView:
// These are valid parameter, so allow them.
break;
default:
result.IsValid = false;
result.ValidationErrors += string.Format(CultureInfo.InvariantCulture,
Resources.PARAMETERUNKNOWNEBIWU,
parameter.Key);
break;
}
}
return(result);
}
/// <summary>
/// Submit the search request with the user supplied configuration parameters and sequence
/// Implementation should make use of the Bio.IO formatters to convert the sequence into
/// the web interface compliant sequence format
/// </summary>
/// <remarks>An exception is thrown if the request does not succeed.</remarks>
/// <param name="sequences">List of sequence to search with</param>
/// <param name="parameters">Blast input parameters</param>
/// <returns>Request Identifier</returns>
public string SubmitRequest(IList <ISequence> sequences, BlastParameters parameters)
{
string emailAddress = string.Empty;
if (null == sequences)
{
throw new ArgumentNullException("sequences");
}
if (null == parameters)
{
throw new ArgumentNullException("parameters");
}
string tempEmail;
if (parameters.Settings.TryGetValue(ParameterEmail, out tempEmail) &&
!string.IsNullOrEmpty(tempEmail))
{
emailAddress = tempEmail;
}
string requestIdentifier = string.Empty;
// Validate the Parameter
ParameterValidationResult valid = ValidateParameters(parameters);
if (!valid.IsValid)
{
throw new Exception(valid.ValidationErrors);
}
// Submit the job to server
InputParameters blastRequest = GetRequestParameter(parameters);
StringBuilder seqBuilder = new StringBuilder();
foreach (ISequence sequence in sequences)
{
byte[] buffer = new byte[80];
int bufferIndex = 0, maxLineSize = 80;
seqBuilder.AppendLine(">" + sequence.ID);
for (long index = 0; index < sequence.Count; index += maxLineSize)
{
for (bufferIndex = 0; bufferIndex < maxLineSize && index + bufferIndex < sequence.Count; bufferIndex++)
{
buffer[bufferIndex] = sequence[index + bufferIndex];
}
string line = ASCIIEncoding.ASCII.GetString(buffer, 0, bufferIndex);
seqBuilder.AppendLine(line);
}
}
blastRequest.sequence = seqBuilder.ToString();
requestIdentifier = blastClient.run(emailAddress, string.Empty, blastRequest);
// Only if the event is registered, invoke the thread
if (null != RequestCompleted)
{
BlastThreadParameter threadParameter = new BlastThreadParameter(
requestIdentifier,
null,
parameters);
// 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(threadParameter);
}
return(requestIdentifier);
}
/// <summary>
/// Submit the search request with the user supplied configuration parameters
/// and sequence. Implementation should make use of the Bio.IO formatters
/// to convert the sequence into the web interface compliant sequence format.
/// This method performs parameter validation and throw Exception on invalid input.
/// </summary>
/// <remarks>An exception is thrown if the request does not succeed.</remarks>
/// <param name="sequence">The sequence to search with</param>
/// <param name="parameters">Blast input parameters</param>
/// <returns>Request Identifier</returns>
public string SubmitRequest(ISequence sequence, BlastParameters parameters)
{
if (null != sequence)
{
parameters.Add("Query", sequence.ToString());
}
if (null == parameters)
{
throw new ArgumentNullException("parameters");
}
string requestIdentifier = string.Empty;
// Validate the Parameter
ParameterValidationResult valid = ValidateParameters(parameters);
if (!valid.IsValid)
{
throw new Exception(valid.ValidationErrors);
}
parameters.Add(PARAMETERCOMMAND, COMMANDPUT);
Stream responseStream = null;
string statusDescription = string.Empty;
WebAccessor accessor = new WebAccessor();
if (Configuration.UseBrowserProxy)
{
accessor.GetBrowserProxy();
}
if (!accessor.SubmitHttpRequest(
ServiceUri,
true, // do POST
parameters.Settings, // request parameters
out statusDescription,
out responseStream))
{
// failed
accessor.Close();
throw new Exception(String.Format(
Resource.HTTPSUBMITFAILED,
statusDescription));
}
string response = string.Empty;
using (StreamReader r = new StreamReader(responseStream))
{
response = r.ReadToEnd();
string info = ExtractInfoSection(response);
if (!String.IsNullOrEmpty(info))
{
int ridStart = info.IndexOf("RID = ");
if (ridStart >= 0)
{
ridStart += "RID = ".Length;
int ridEnd = info.IndexOf('\n', ridStart);
if (ridEnd >= 0)
{
requestIdentifier = info.Substring(ridStart, ridEnd - ridStart);
}
}
}
r.Close();
}
accessor.Close();
if (string.IsNullOrEmpty(requestIdentifier))
{
string message = String.Format(
Resource.RIDEXTRACTFAILED,
ExtractError(response));
throw new Exception(message);
}
// Only if the event is registered, invoke the thread
if (null != RequestCompleted)
{
ThreadParameter threadParameter = new ThreadParameter(
requestIdentifier,
sequence,
parameters);
// 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(threadParameter);
}
return(requestIdentifier);
}
/// <summary>
/// Submit the search request with the user supplied configuration parameters
/// and sequence. Implementation should make use of the Bio.IO formatters
/// to convert the sequence into the web interface compliant sequence format.
/// This method performs parameter validation and throw Exception on invalid input.
/// </summary>
/// <remarks>An exception is thrown if the request does not succeed.</remarks>
/// <param name="sequence">The sequence to search with</param>
/// <param name="parameters">Blast input parameters</param>
/// <returns>Request Identifier</returns>
public string SubmitRequest(ISequence sequence, BlastParameters parameters)
{
if (null == sequence)
{
throw new ArgumentNullException("sequence");
}
if (null == parameters)
{
throw new ArgumentNullException("parameters");
}
if (!string.IsNullOrEmpty(Configuration.EmailAddress))
{
if (!parameters.Settings.ContainsKey(ParameterEmail))
{
parameters.Add(ParameterEmail, Configuration.EmailAddress);
}
}
string requestIdentifier = string.Empty;
// Validate the Parameter
ParameterValidationResult valid = ValidateParameters(parameters);
if (!valid.IsValid)
{
throw new Exception(valid.ValidationErrors);
}
// Submit the job to server
inputParams blastRequest = GetRequestParameter(parameters);
blastRequest.appxml = AppXmlYes;
blastRequest.async = true;
data[] mydata = new data[1];
mydata[0] = new data();
mydata[0].type = SequenceType;
mydata[0].content = FastAFormatter.FormatString(sequence);
requestIdentifier = blastClient.runWUBlast(blastRequest, mydata);
// Only if the event is registered, invoke the thread
if (null != RequestCompleted)
{
BlastThreadParameter threadParameter = new BlastThreadParameter(
requestIdentifier,
sequence,
parameters);
// 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(threadParameter);
}
return(requestIdentifier);
}