public IEnumerable <string> GetProducts(string content, int lineNumber)
{
SLogger.LogDebugFormat("Line number {0} is a question.", lineNumber);
if (string.IsNullOrEmpty(content) || string.IsNullOrWhiteSpace(content))
{
SLogger.LogWarnFormat("Line number {0} does not have valid product(s). Skipping...", lineNumber);
return(null);
}
string[] products = content.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
foreach (string product in products)
{
if (!this.productsList.Contains(product))
{
SLogger.LogInfoFormat("Product List (derived by reading the input lines) does not contain product uptil now:{0} at line number {1}.\nSkipping...",
product, lineNumber);
return(null);
}
}
return(products);
}
public string Validate(int numeral)
{
SLogger.LogInfoFormat("Validating {0}", numeral);
ValidationResult result = this.arabicNumeralValidator.Validate(numeral);
return(this.Validate(result));
}
public IEnumerable <string> Analyze(IEnumerable <Tuple <int, InputType, IEnumerable <string>, string> > contents)
{
ICollection <string> analyzedResponses = new Collection <string>();
if (contents != null && contents.Any())
{
foreach (Tuple <int, InputType, IEnumerable <string>, string> content in contents)
{
int lineNumber = content.Item1;
InputType typeOfInput = content.Item2;
IEnumerable <string> products = content.Item3;
string productValue = content.Item4;
SLogger.LogInfoFormat("Analyzing line number {0}.", lineNumber);
try
{
Tuple <int, IEnumerable <string>, string> contentToInterpret =
new Tuple <int, IEnumerable <string>, string>(lineNumber, products, productValue);
switch (typeOfInput)
{
case InputType.ProductData:
{
if (products == null || !products.Any())
{
SLogger.LogWarn("No products found to analyze. Skipping product data intrepretation...");
continue;
}
this.productDataInterpreter.Interpret(contentToInterpret);
}
break;
case InputType.Query:
{
string queryResponse = this.queryInterpreter.Interpret(contentToInterpret);
analyzedResponses.Add(queryResponse);
}
break;
default:
throw new InvalidOperationException("Invalid InputType Enum.");
}
}
catch (Exception ex)
{
SLogger.LogErrorFormat(ex, "Exception found when Analyzing line: {0}.", lineNumber);
}
}
}
return(analyzedResponses);
}
private void ProcessContent(string content, int lineNumber,
InputType typeOfInput, out IEnumerable <string> products, out string productValue)
{
SLogger.LogInfoFormat("Preprocessing line number {0} with content {1}", lineNumber, content);
products = new Collection <string>();
productValue = string.Empty;
if (content.IndexOf(" is ", StringComparison.OrdinalIgnoreCase) == -1)
{
SLogger.LogWarnFormat("{0} at line number {1} does not contain 'is' keyword. Skipping...", content, lineNumber);
return;
}
string[] words = content.Split(new string[] { " is " }, StringSplitOptions.None);
if (words.Length != 2)
{
SLogger.LogWarnFormat("{0} at line number {1} is not properly formatted. Skipping...", content, lineNumber);
return;
}
switch (typeOfInput)
{
case InputType.ProductData:
{
products = this.productDataValidator.GetProducts(words[0].Trim(), lineNumber);
if (products == null || !products.Any())
{
return;
}
productValue = this.productDataValidator.GetProductValue(words[1].Trim(), lineNumber);
}
break;
case InputType.Query:
{
products = this.queryValidator.GetProducts(words[1].Replace("?", string.Empty).Trim(), lineNumber);
productValue = words[0].IndexOf(CREDITS_TEXT) != -1 ? CREDITS_TEXT : string.Empty;
}
break;
default: // This won't hit, since GetInputType will always return either of ProductData or Query as InputType
throw new InvalidOperationException("Invalid InputType Enum.");
}
}
private bool UpdateProductCache(string product, int lineNumber)
{
if (!this.productsList.Contains(product))
{
if (this.productCategorizer.IsProductValid(product))
{
SLogger.LogInfoFormat("Line number {0} contains valid product:{1}.", lineNumber, product);
this.productsList.Add(product);
return(true);
}
else
{
SLogger.LogWarnFormat("Line number {0} contained an invalid product entry:{1}, Skipping...", lineNumber, product);
return(false);
}
}
SLogger.LogInfoFormat("Line number {0} contains valid product:{1}. Found in 'in-memory' list of products. Skipping adding to it.", lineNumber, product);
return(true);
}
public int Interpret(Tuple <int, IEnumerable <string>, string> content)
{
int lineNumber = content.Item1;
IEnumerable <string> products = content.Item2;
string productValue = content.Item3;
SLogger.LogInfoFormat("Interpreting Product(s) at line number {0}.", lineNumber);
if (products == null || !products.Any())
{
return(0);
}
if (!this.validator.IsProductRepresentationValid(products, productValue, InputType.ProductData, lineNumber, intergalacticProductsCache))
{
return(0);
}
this.InterpretProducts(products, productValue);
return(1);
}
public string Interpret(Tuple <int, IEnumerable <string>, string> content)
{
int lineNumber = content.Item1;
IEnumerable <string> products = content.Item2;
string responseFormat = content.Item3;
SLogger.LogInfoFormat("Interpreting Query at line number {0}.", lineNumber);
if (products == null || !products.Any())
{
return(INVALID_RESPONSE);
}
if (!this.validator.IsProductRepresentationValid(products, null, InputType.Query, lineNumber, intergalacticProductsCache))
{
return(INVALID_RESPONSE);
}
OutputUnitType outputUnit = this.GetOutputUnitType(responseFormat);
return(this.InterpretProducts(products, outputUnit));
}
