/// <summary>
/// Analyse the connection to get the definition back
/// </summary>
/// <param name="request">The analysis request paramaters</param>
/// <returns>The data item definition derived from the connection and object</returns>
public override DataItemDefinition Analyse(AnalyseRequest <object> request)
{
DataItemDefinition result = new DataItemDefinition(); // Empty Response By Default
// Are we connected and have an object name?
if ((this.ObjectName ?? String.Empty) != String.Empty &&
this.Connected)
{
// Set up the command to run and select all columns from the object
using (SqlCommand command =
new SqlCommand($"select top {request.SampleSize.ToString()} * from {this.ObjectName}", this.sqlConnection))
{
// Run the command
using (SqlDataReader dataReader = command.ExecuteReader())
{
DataTable tempTable = new DataTable(); // Create a temporary table
tempTable.Load(dataReader); // Run the data reader to load the results
result.FromDataTable(tempTable); // Tell the definition to load itself from the data table provided
// Clean up
tempTable = null;
}
}
}
// Send the result back
return(result);
}
/// <summary>
/// Look at the file and try and represent the file as a dataset without a definition
/// </summary>
/// <returns>A representation of the data</returns>
public override DataItemDefinition Analyse(AnalyseRequest <Object> request)
{
// Create a blank result data table
DataItemDefinition result = new DataItemDefinition()
{
};
String rawData = ""; // The data which ultimately will be read from
// Check to see what can of analysis is being requested
if ((request.Connection?.ConnectionString ?? String.Empty) != String.Empty)
{
// Get the stream of data from the raw file
rawData = File.ReadAllText(request.Connection.ConnectionStringProcessed);
}
else
{
// No connection was provided so use the raw data provided instead
switch (request.Data.GetType().ToShortName())
{
case "string":
rawData = (String)request.Data;
break;
default:
((Stream)request.Data).Position = 0; // Reset the stream position
// Read the data from the stream
StreamReader reader = new StreamReader((Stream)request.Data);
rawData = reader.ReadToEnd();
// Reset the position again so that it can be re-used
((Stream)request.Data).Position = 0;
break;
}
}
// Pass down to the analyse text core function
AnalyseRequest <String> analyseTextRequest =
new AnalyseRequest <String>()
{
Data = rawData,
Connection = request.Connection
};
result = DelimitedFileHelper.AnalyseText(analyseTextRequest);
base.MarkLastAction(); // Tell the provider base class that it did something
// Send the analysis data table back
return(result);
}
/// <summary>
/// Analyses input submitted by user.
/// </summary>
/// <param name="request">Analyse request.</param>
/// <returns>Returns analyse result.</returns>
public async Task <AnalysisResult> Analyse(AnalyseRequest request)
{
var result = new AnalysisResult(request);
if (request.IsCalculateOccurrencesOfEachWords)
{
var splittedString = await SplitWords(request.Input, request.IsRemoveStopWords);
result.WordsAndCount = await CalculateOccurrences(splittedString, splittedString.Distinct().ToList());
}
return(result);
}
/// <summary>
/// Analyses input from user.
/// </summary>
/// <param name="request">Analyse request.</param>
/// <returns>Analysis results.</returns>
public async Task <ActionResult> Analyse(AnalyseRequest request)
{
if (!ModelState.IsValid)
{
ViewBag.Error = "Text or URL is required!";
return(View("Index", request));
}
var isInputUrl = Uri.IsWellFormedUriString(request.Input, UriKind.Absolute);
var result = new AnalysisResult(request);
if (!new bool[]
{
request.IsCalculateKeywordsInMetaTags,
request.IsCalculateNumberOfExternalLinks,
request.IsCalculateOccurrencesOfEachWords
}.Any(x => x))
{
ViewBag.Warning = "No Analysis Result Type selected!";
return(View(result));
}
if (!isInputUrl && !request.IsCalculateOccurrencesOfEachWords)
{
ViewBag.Warning = "'Calculate Occurrences of Each Words?' must be checked when analysing words.";
return(View(result));
}
try
{
ISeoAnalyser analyser = isInputUrl ? new HtmlAnalyser(new LinkAnalyser(), new MetaAnalyser(), new WordAnalyser()) as ISeoAnalyser : new WordAnalyser() as ISeoAnalyser;
result = await analyser.Analyse(request);
}
catch (HttpRequestException)
{
ViewBag.Error = $"{request.Input} is invalid!";
}
catch (Exception)
{
ViewBag.Error = $"Unknown error.";
}
return(View(result));
}
public void Analyse_BigData_RowCount()
{
// Arrange
TestHelper testHelper = new TestHelper();
Stream file = testHelper.GetResourceStream(
TestHelper.TestFile_BigFileSalesRecords);
DataConnection connection = testHelper.TestConnection();
DelimitedFileProvider provider = new DelimitedFileProvider();
// Act
AnalyseRequest <Object> analysisRequest = new AnalyseRequest <Object>()
{
Data = file,
Connection = connection
};
DataItemDefinition definition = provider.Analyse(analysisRequest);
provider.Connect(definition, analysisRequest.Connection, file);
DataTable data = provider.Read("");
// Assert
Assert.Equal(5000, data.Rows.Count);
}
/// <summary>
/// Fetch and analyses web page from uri submitted by user.
/// </summary>
/// <param name="request">Analyse request.</param>
/// <returns>Returns analyse results.</returns>
public async Task <AnalysisResult> Analyse(AnalyseRequest request)
{
var result = new AnalysisResult(request);
var response = await httpClient.GetAsync(request.Input);
if (response.IsSuccessStatusCode)
{
List <string> splittedString = new List <string>();
var html = await response.Content.ReadAsStringAsync();
if (request.IsCalculateOccurrencesOfEachWords || request.IsCalculateKeywordsInMetaTags)
{
var doc = new HtmlDocument();
doc.LoadHtml(html);
splittedString = await wordAnalyser.SplitWords(doc.DocumentNode.SelectNodes("//body")?.FirstOrDefault()?.InnerText ?? "", request.IsRemoveStopWords);
}
if (request.IsCalculateOccurrencesOfEachWords)
{
result.WordsAndCount = await wordAnalyser.CalculateOccurrences(splittedString, splittedString.Distinct().ToList());
}
if (request.IsCalculateKeywordsInMetaTags)
{
var wordsInMetaTags = await metaAnalyser.GetMetaData(html);
result.WordsInMetaTagsAndCount = await wordAnalyser.CalculateOccurrences(splittedString, wordsInMetaTags);
}
if (request.IsCalculateNumberOfExternalLinks)
{
result.ExternalLinks = await linkAnalyser.GetExternalLinks(html);
}
}
return(result);
}
/// <summary> /// Analyse the connection to build a data item definition /// </summary> /// <param name="request">The parameters of the connection request</param> /// <returns>A data item definition based on the requested connection</returns> public virtual DataItemDefinition Analyse(AnalyseRequest <Object> request) => throw new NotImplementedException();
