public string DownloadFile(OutputParametersViewModel analysisResults)
{
var analysisDictionary = new AnalysisDictionary();
this.GetValuesFromProperty(analysisResults.CommonResults, analysisDictionary);
this.GetValuesFromProperty(analysisResults.NightWatchmanResults, analysisDictionary);
// Generate Shopping included and excluded files
var excludedFilename = Path.Combine(ApplicationSettings.OutputFolderPath, "Shopping Excluded Programs.txt");
var includedFilename = Path.Combine(ApplicationSettings.OutputFolderPath, "Shopping Included Programs.txt");
Exclusions.ExclusionFilter = (string)EnvironmentSettings.GetConfigSectionValues("Shopping")["ShoppingDefaultExclusions"];
Exclusions.GenerateIncludedAndExcludedFiles(includedFilename, excludedFilename);
// Create zip file
var filesToZip = new List<ZipFileEntry>
{
new ZipFileEntry(NightWatchmanController.GenerateReport(analysisResults, ReportType.Word)),
new ZipFileEntry(NightWatchmanController.GenerateReport(analysisResults, ReportType.Pdf)),
new ZipFileEntry(ShoppingController.GenerateReport(analysisResults, ReportType.Word)),
new ZipFileEntry(ShoppingController.GenerateReport(analysisResults, ReportType.Pdf)),
new ZipFileEntry(excludedFilename),
new ZipFileEntry(includedFilename)
};
var zipFileName = string.Format("{0}_Results_{1}.zip", analysisResults.CommonResults.CompanyName, DateTime.UtcNow.ToString("yyyy_MM_dd_hh_m_ss"));
const string ZipPassword = "";
ZipPackage.PackageFiles(
filesToZip, Path.Combine(ApplicationSettings.OutputFolderPath, zipFileName), ZipPassword);
return zipFileName;
}
public void Growth()
{
var dict = new AnalysisDictionary <string, string>();
for (int i = 0; i < 25; i++)
{
dict[i.ToString()] = i.ToString();
for (int j = 0; j < i; j++)
{
Assert.AreEqual(j.ToString(), dict[j.ToString()]);
}
}
dict = new AnalysisDictionary <string, string>(15);
for (int i = 0; i < 25; i++)
{
dict[i.ToString()] = i.ToString();
for (int j = 0; j < i; j++)
{
Assert.AreEqual(j.ToString(), dict[j.ToString()]);
}
}
}
public string DownloadFile(OutputParametersViewModel analysisResults)
{
var analysisDictionary = new AnalysisDictionary();
this.GetValuesFromProperty(analysisResults.CommonResults, analysisDictionary);
this.GetValuesFromProperty(analysisResults.NightWatchmanResults, analysisDictionary);
// Generate Shopping included and excluded files
var excludedFilename = Path.Combine(ApplicationSettings.OutputFolderPath, "Shopping Excluded Programs.txt");
var includedFilename = Path.Combine(ApplicationSettings.OutputFolderPath, "Shopping Included Programs.txt");
Exclusions.ExclusionFilter = (string)EnvironmentSettings.GetConfigSectionValues("Shopping")["ShoppingDefaultExclusions"];
Exclusions.GenerateIncludedAndExcludedFiles(includedFilename, excludedFilename);
// Create zip file
var filesToZip = new List <ZipFileEntry>
{
new ZipFileEntry(NightWatchmanController.GenerateReport(analysisResults, ReportType.Word)),
new ZipFileEntry(NightWatchmanController.GenerateReport(analysisResults, ReportType.Pdf)),
new ZipFileEntry(ShoppingController.GenerateReport(analysisResults, ReportType.Word)),
new ZipFileEntry(ShoppingController.GenerateReport(analysisResults, ReportType.Pdf)),
new ZipFileEntry(excludedFilename),
new ZipFileEntry(includedFilename)
};
var zipFileName = string.Format("{0}_Results_{1}.zip", analysisResults.CommonResults.CompanyName, DateTime.UtcNow.ToString("yyyy_MM_dd_hh_m_ss"));
const string ZipPassword = "";
ZipPackage.PackageFiles(
filesToZip, Path.Combine(ApplicationSettings.OutputFolderPath, zipFileName), ZipPassword);
return(zipFileName);
}
private void EnsureSize(int newSize) {
// see if we can reclaim collected buckets before growing...
var oldBuckets = _buckets;
if (_buckets == null) {
_buckets = new Bucket[newSize];
return;
}
if (oldBuckets != null) {
for (int i = 0; i < oldBuckets.Length; i++) {
var curBucket = oldBuckets[i];
if (curBucket.Key != null && !curBucket.Key.IsAlive) {
oldBuckets[i].Key = _removed;
newSize--;
_count--;
}
}
}
if (newSize > oldBuckets.Length) {
newSize = AnalysisDictionary<object, object>.GetPrime(newSize);
var newBuckets = new Bucket[newSize];
for (int i = 0; i < oldBuckets.Length; i++) {
var curBucket = oldBuckets[i];
if (curBucket.Key != null &&
curBucket.Key != _removed) {
AddOne(newBuckets, curBucket.Key, curBucket.HashCode);
}
}
_buckets = newBuckets;
}
}
public AnalysisDictionary Analyse(string connectionString, AnalysisDictionary values)
{
this.ConnectionString = connectionString;
var analysisResult = new AnalysisDictionary { Name = "Shopping" };
var period = Convert.ToInt32(values["Period"].Value);
var startDate = Convert.ToDateTime(values["StartDate"].Value);
var endDate = Convert.ToDateTime(values["EndDate"].Value);
var threshold = Convert.ToInt32(values["Threshold"].Value);
var costPerRequest = Convert.ToInt32(values["CostPerRequest"].Value);
var currencySymbol = Convert.ToString(values["CurrencySymbol"].Value);
analysisResult.Add("Period", new AnalysisAttribute { Value = string.Format("{0:n0}", period) });
analysisResult.Add("StartDate", new AnalysisAttribute { Value = startDate.ToString("d-MMMM-yyyy") });
analysisResult.Add("EndDate", new AnalysisAttribute { Value = endDate.ToString("d-MMMM-yyyy") });
analysisResult.Add("CurrencySymbol", new AnalysisAttribute { Value = currencySymbol });
analysisResult.Add("CostPerRequest", new AnalysisAttribute { Value = string.Format("{0:n0}", costPerRequest) });
var exclusionFilter = Exclusions.GetExclusionFilter(this.ConnectionString);
// Total number of requests
GetTotalNumberOfRequests(analysisResult, exclusionFilter, startDate, endDate, period, threshold, costPerRequest, currencySymbol);
// Top program list
var maximumNoOfProgramsToRetreive = Convert.ToInt32(values["MaximumNoOfProgramsToRetreive"].Value);
// This will be used later when the report supports it.
var ds = GetTopProgramList(exclusionFilter, startDate, endDate, maximumNoOfProgramsToRetreive, threshold);
return analysisResult;
}
private void CreateSQLParameterArray(AnalysisDictionary values, out SqlParameter[] sqlParamArray)
{
int startTimeInMns = 420;
int endTimeInMns = 1140;
if (values.ContainsKey("Startofworkingday"))
{
AnalysisAttribute startTimeValue = values["Startofworkingday"];
string[] startTimeVal = startTimeValue.Value.Split(':');
int hourResult, minuteResult;
if (int.TryParse(startTimeVal[0], out hourResult) && int.TryParse(startTimeVal[1], out minuteResult))
{
startTimeInMns = (hourResult * 60) + minuteResult;
}
}
if (values.ContainsKey("Endofworkingday"))
{
AnalysisAttribute endTimeValue = values["Endofworkingday"];
string[] endTimeVal = endTimeValue.Value.Split(':');
int hourResult, minuteResult;
if (int.TryParse(endTimeVal[0], out hourResult) && int.TryParse(endTimeVal[1], out minuteResult))
{
endTimeInMns = (hourResult * 60) + minuteResult;
}
}
sqlParamArray = new[]
{
new SqlParameter("@starttime", SqlDbType.Int) { Value = startTimeInMns },
new SqlParameter("@endtime", SqlDbType.Int) { Value = endTimeInMns }
};
}
public void Collision()
{
// difference object reference, but equal.
var dict = new AnalysisDictionary <Hashable, string>();
List <Hashable> items = new List <Hashable>();
for (int i = 0; i < 25; i++)
{
var item = new Hashable(1);
items.Add(item);
dict[item] = i.ToString();
}
for (int i = 0; i < items.Count; i++)
{
Assert.AreEqual(i.ToString(), dict[items[i]]);
}
for (int i = 0; i < items.Count; i++)
{
dict.Remove(items[i]);
for (int j = i + 1; j < items.Count; j++)
{
Assert.AreEqual(j.ToString(), dict[items[j]]);
}
}
}
public void AddRemoveAdd()
{
// same object reference
var dict = new AnalysisDictionary <string, string>();
var value = "1";
dict.Add(value, "One");
dict[value] = "Two";
Assert.AreEqual(1, dict.Count);
Assert.AreEqual("Two", dict["1"]);
// difference object reference, but equal.
var dict2 = new AnalysisDictionary <Hashable, string>();
var one = new Hashable(1, (self, x) => x._hash == 1);
var two = new Hashable(1, (self, x) => x._hash == 1);
dict2.Add(one, "One");
dict2[two] = "Two";
Assert.AreEqual("Two", dict2[one]);
Assert.AreEqual("Two", dict2[two]);
Assert.AreEqual(1, dict2.Count);
dict2 = new AnalysisDictionary <Hashable, string>();
dict2.Add(new Hashable(1), "One");
Assert.AreEqual(false, dict2.Remove(new Hashable(2)));
}
private void EnsureDescriptors()
{
if (_descriptors == null)
{
_descriptors = new AnalysisDictionary <string, PropertyDescriptorValue>();
_descriptorDependencies = new DependentData();
}
}
public AnalysisDictionary Analyse(string connectionString, AnalysisDictionary values)
{
ConnectionString = connectionString;
var analysisResult = new AnalysisDictionary { Name = "Shopping" };
var queries = GetQueries(analysisResult);
RunQueries(queries, analysisResult);
return analysisResult;
}
public AnalysisDictionary Analyse(string connectionString, AnalysisDictionary values)
{
this.ConnectionString = connectionString;
var analysisResult = new AnalysisDictionary { Name = "NightWatchman" };
IEnumerable<SqlAnalysisQuery> queries = this.GetQueries(analysisResult);
this.RunQueries(queries, analysisResult, values);
return analysisResult;
}
public void AddExisting()
{
var dict = new AnalysisDictionary <string, string>()
{
{ "1", "One" }
};
AssertUtil.Throws <ArgumentException>(() => dict.Add("1", "Two"));
}
protected DeclarativeEnvironmentRecord(DeclarativeEnvironmentRecord cloned, bool isCloned)
: base(cloned, isCloned) {
_variables = cloned._variables;
if (cloned._linkedVariables == null) {
// linkedVariables could be created later, and we need to share them if it.
cloned._linkedVariables = new Dictionary<string, HashSet<VariableDef>>();
}
_linkedVariables = cloned._linkedVariables;
}
protected InterpreterScope(AnalysisValue av, InterpreterScope cloned, bool isCloned) {
Debug.Assert(isCloned);
_av = av;
Children.AddRange(cloned.Children);
_nodeScopes = cloned._nodeScopes;
_nodeValues = cloned._nodeValues;
_variables = cloned._variables;
_linkedVariables = cloned._linkedVariables;
}
/// <summary>
/// Fills all the <see cref="OpenXmlElement"></see>
/// that are found in a given <see cref="OpenXmlElement"/>.
/// </summary>
/// <param name="values">The values to insert; keys should match the placeholder names, values are the data to insert.</param>
/// <param name="element">The document element taht will contain the new values.</param>
private void FillWordFieldsInElement(AnalysisDictionary values, OpenXmlElement element)
{
var emptyfields = new Dictionary <SimpleField, string[]>();
// First pass: fill in data, but do not delete empty fields. Deletions silently break the loop.
var list = element.Descendants <SimpleField>().ToArray();
foreach (var field in list)
{
string[] switches;
string[] options;
string fieldname = GetFieldNameWithOptions(field, out switches, out options);
if (!string.IsNullOrEmpty(fieldname))
{
if (values.ContainsKey(fieldname) &&
!string.IsNullOrEmpty(values[fieldname].Value))
{
string[] formattedText = ApplyFormatting(options[0], values[fieldname].Value, options[1], options[2]);
// Prepend any text specified to appear before the data in the MergeField
if (!string.IsNullOrEmpty(options[1]))
{
// ReSharper disable RedundantTypeArgumentsOfMethod
field.Parent.InsertBeforeSelf <Paragraph>(GetPreOrPostParagraphToInsert(formattedText[1], field));
// ReSharper restore RedundantTypeArgumentsOfMethod
}
// Append any text specified to appear after the data in the MergeField
if (!string.IsNullOrEmpty(options[2]))
{
// ReSharper disable RedundantTypeArgumentsOfMethod
field.Parent.InsertAfterSelf <Paragraph>(GetPreOrPostParagraphToInsert(formattedText[2], field));
// ReSharper restore RedundantTypeArgumentsOfMethod
}
// replace mergefield with text
// ReSharper disable RedundantTypeArgumentsOfMethod
field.Parent.ReplaceChild <SimpleField>(GetRunElementForText(formattedText[0], field), field);
// ReSharper restore RedundantTypeArgumentsOfMethod
}
else
{
// keep track of unknown or empty fields
emptyfields[field] = switches;
}
}
}
// second pass : clear empty fields
foreach (KeyValuePair <SimpleField, string[]> kvp in emptyfields)
{
// if field is unknown or empty: execute switches and remove it from document !
ExecuteSwitches(kvp.Key, kvp.Value);
kvp.Key.Remove();
}
}
protected InterpreterScope(AnalysisValue av, InterpreterScope cloned, bool isCloned)
{
Debug.Assert(isCloned);
_av = av;
Children.AddRange(cloned.Children);
_nodeScopes = cloned._nodeScopes;
_nodeValues = cloned._nodeValues;
_variables = cloned._variables;
_linkedVariables = cloned._linkedVariables;
}
public InterpreterScope(AnalysisValue av, Node ast, InterpreterScope outerScope) {
_av = av;
_node = ast;
OuterScope = outerScope;
_nodeScopes = new AnalysisDictionary<Node, InterpreterScope>();
_nodeValues = new AnalysisDictionary<Node, IAnalysisSet>();
_variables = new AnalysisDictionary<string, VariableDef>();
_linkedVariables = new AnalysisDictionary<string, HashSet<VariableDef>>();
}
public void RemoveExisting()
{
var dict = new AnalysisDictionary <Hashable, string>();
var one = new Hashable(1, (self, x) => x._hash == 1);
var two = new Hashable(1, (self, x) => x._hash == 1);
dict.Add(one, "One");
dict.Remove(two);
Assert.AreEqual(0, dict.Count);
}
public InterpreterScope(AnalysisValue av, Node ast, InterpreterScope outerScope)
{
_av = av;
_node = ast;
OuterScope = outerScope;
_nodeScopes = new AnalysisDictionary <Node, InterpreterScope>();
_nodeValues = new AnalysisDictionary <Node, NodeValue>();
_variables = new AnalysisDictionary <string, VariableDef>();
_linkedVariables = new AnalysisDictionary <string, HashSet <VariableDef> >();
}
protected DeclarativeEnvironmentRecord(DeclarativeEnvironmentRecord cloned, bool isCloned)
: base(cloned, isCloned)
{
_variables = cloned._variables;
if (cloned._linkedVariables == null)
{
// linkedVariables could be created later, and we need to share them if it.
cloned._linkedVariables = new Dictionary <string, HashSet <VariableDef> >();
}
_linkedVariables = cloned._linkedVariables;
}
public AnalysisDictionary Analyse(string connectionString, AnalysisDictionary values)
{
ConnectionString = connectionString;
var analysisResult = new AnalysisDictionary {
Name = "Shopping"
};
var queries = GetQueries(analysisResult);
RunQueries(queries, analysisResult);
return(analysisResult);
}
public AnalysisDictionary Analyse(string connectionString, AnalysisDictionary values)
{
this.ConnectionString = connectionString;
var analysisResult = new AnalysisDictionary {
Name = "NightWatchman"
};
IEnumerable <SqlAnalysisQuery> queries = this.GetQueries(analysisResult);
this.RunQueries(queries, analysisResult, values);
return(analysisResult);
}
private void RunQueries(IEnumerable<SqlAnalysisQuery> queries, AnalysisDictionary values)
{
using (var cnn = new SqlConnection(this.ConnectionString))
{
cnn.Open();
var runner = new SqlAnalysisQueryRunner();
foreach (var query in queries)
{
runner.Run(cnn, query, values , null);
}
}
}
private void RunQueries(IEnumerable <SqlAnalysisQuery> queries, AnalysisDictionary values)
{
using (var cnn = new SqlConnection(this.ConnectionString))
{
cnn.Open();
var runner = new SqlAnalysisQueryRunner();
foreach (var query in queries)
{
runner.Run(cnn, query, values, null);
}
}
}
protected InterpreterScope(AnalysisValue av, InterpreterScope cloned, bool isCloned)
{
Debug.Assert(isCloned);
AnalysisValue = av;
Children = cloned.Children.ToList();
_nodeScopes = cloned._nodeScopes;
_nodeValues = cloned._nodeValues;
_variables = cloned._variables;
_linkedVariables = cloned._linkedVariables;
OriginalScope = cloned.OriginalScope;
_linkedScopes = cloned._linkedScopes;
}
public InterpreterScope(AnalysisValue av, Node ast, InterpreterScope outerScope)
{
AnalysisValue = av;
Node = ast;
OuterScope = outerScope;
Children = new List <InterpreterScope>();
_nodeScopes = new AnalysisDictionary <Node, InterpreterScope>();
_nodeValues = new AnalysisDictionary <Node, NodeValue>();
_variables = new AnalysisDictionary <string, VariableDef>();
_linkedVariables = new AnalysisDictionary <string, HashSet <IVariableDefinition> >();
_linkedScopes = new List <InterpreterScope>();
}
public void Threaded()
{
var dict = new AnalysisDictionary <string, string>();
var keys = new[] { "1", "2", "3", "4", "5", "6" };
foreach (var key in keys)
{
dict[key] = "0";
}
bool exit = false;
var thread = new Thread(() => {
int count = 1;
while (!exit)
{
var countStr = count.ToString();
foreach (var key in keys)
{
dict[key] = countStr;
}
count++;
}
});
thread.Start();
Dictionary <string, int> lastKey = new Dictionary <string, int>();
foreach (var key in keys)
{
lastKey[key] = 0;
}
for (int i = 0; i < 10000000; i++)
{
foreach (var key in keys)
{
var value = Int32.Parse(dict[key]);
Assert.IsTrue(value >= lastKey[key]);
lastKey[key] = value;
}
foreach (var kvp in dict)
{
var value = Int32.Parse(kvp.Value);
Assert.IsTrue(value >= lastKey[kvp.Key]);
lastKey[kvp.Key] = value;
}
}
exit = true;
}
public static string GenerateWordReport(AnalysisDictionary reportValues, string outputPath, string templatePath)
{
if (File.Exists(outputPath))
{
File.Delete(outputPath);
}
var manager = new WordManager { MergeColsValues = reportValues, FileName = templatePath };
var content = manager.Bind();
File.Copy(templatePath, outputPath);
File.WriteAllBytes(outputPath, content);
return outputPath;
}
private void GetValuesFromProperty(object obj, AnalysisDictionary dictionaryUsedForAnalysis)
{
PropertyInfo[] properties = obj.GetType().GetProperties();
foreach (PropertyInfo property in properties)
{
object o = property.GetValue(obj, null);
var objAnalysisAttribute = new AnalysisAttribute {
Value = Convert.ToString(o)
};
dictionaryUsedForAnalysis.Add(property.Name, objAnalysisAttribute);
}
}
internal void MakeUnionStronger()
{
var cmp = KeyValues.Comparer as UnionComparer;
if (cmp != null && cmp.Strength == UnionComparer.MAX_STRENGTH)
{
return;
}
if (cmp == null)
{
cmp = UnionComparer.Instances[0];
}
else
{
cmp = UnionComparer.Instances[cmp.Strength + 1];
}
var matches = new Dictionary <AnalysisProxy, List <KeyValuePair <AnalysisProxy, IAnalysisSet> > >(cmp);
foreach (var keyValue in KeyValues)
{
List <KeyValuePair <AnalysisProxy, IAnalysisSet> > values;
if (keyValue.Key.Value != null)
{
if (!matches.TryGetValue(keyValue.Key, out values))
{
values = matches[keyValue.Key] = new List <KeyValuePair <AnalysisProxy, IAnalysisSet> >();
}
values.Add(keyValue);
}
}
KeyValues = new AnalysisDictionary <AnalysisProxy, IAnalysisSet>(cmp);
foreach (var list in matches.Values)
{
bool dummy;
var key = list[0].Key;
var value = list[0].Value.AsUnion(cmp, out dummy);
foreach (var item in list.Skip(1))
{
key = cmp.MergeTypes(key, item.Key, out dummy);
value = value.Union(item.Value);
}
KeyValues[key] = value;
}
}
public void Clear()
{
var dict = new AnalysisDictionary <string, string>();
dict.Clear();
Assert.AreEqual(0, dict.Count);
dict.Add("Foo", "Foo");
Assert.AreEqual(1, dict.Count);
dict.Clear();
Assert.AreEqual(0, dict.Count);
dict.Clear();
Assert.AreEqual(0, dict.Count);
}
private List<SqlAnalysisQuery> GetQueries(AnalysisDictionary values)
{
var xmlDocument = XDocument.Parse(Resources.SavingsAnalysis_AnalysisEngine_Dummy);
var analysisQueries = new List<SqlAnalysisQuery>();
foreach (var query in xmlDocument.Descendants("query"))
{
var queryAttrib = query.Element("value");
var nameAttrib = query.Attribute("data");
if (queryAttrib != null && nameAttrib != null && !string.IsNullOrEmpty(queryAttrib.Value) && !string.IsNullOrEmpty(nameAttrib.Value))
{
analysisQueries.Add(new SqlAnalysisQuery(queryAttrib.Value, nameAttrib.Value, nameAttrib.Value));
if (values.ContainsKey(nameAttrib.Value) == false)
values.Add(nameAttrib.Value, new AnalysisAttribute());
}
}
return analysisQueries;
}
public static string GenerateWordReport(AnalysisDictionary reportValues, string outputPath, string templatePath)
{
if (File.Exists(outputPath))
{
File.Delete(outputPath);
}
var manager = new WordManager {
MergeColsValues = reportValues, FileName = templatePath
};
var content = manager.Bind();
File.Copy(templatePath, outputPath);
File.WriteAllBytes(outputPath, content);
return(outputPath);
}
private void RunQueries(
IEnumerable <SqlAnalysisQuery> queries, AnalysisDictionary analysisResult, AnalysisDictionary values)
{
using (var cnn = new SqlConnection(this.ConnectionString))
{
cnn.Open();
var runner = new SqlAnalysisQueryRunner();
foreach (SqlAnalysisQuery query in queries)
{
SqlParameter[] sqlParams;
this.CreateSQLParameterArray(values, out sqlParams);
runner.Run(cnn, query, analysisResult, sqlParams);
}
cnn.Close();
}
}
public void Null()
{
var dict = new AnalysisDictionary <string, string>();
string dummy;
AssertUtil.Throws <ArgumentNullException>(
() => dict.TryGetValue(null, out dummy)
);
AssertUtil.Throws <ArgumentNullException>(
() => dict.Remove(null)
);
AssertUtil.Throws <ArgumentNullException>(
() => dict.Add(null, "")
);
AssertUtil.Throws <ArgumentNullException>(
() => dict.ContainsKey(null)
);
}
public void ThreadedReaderValueRemoved()
{
var comparer = new SynchronizedComparer();
var dict = new AnalysisDictionary <Hashable, string>(comparer);
var key = new Hashable(1, HashEquals);
dict[key] = "0";
var thread = new Thread(() => {
comparer.EqualWaiting.WaitOne();
dict.Remove(key);
dict[new Hashable(1)] = "1";
comparer.DictUpdated.Set();
});
thread.Start();
Assert.IsFalse(dict.ContainsKey(new Hashable(1, HashEquals)));
}
public void TestThreadedReaderUpdatedValue()
{
var comparer = new SynchronizedComparer();
var dict = new AnalysisDictionary <Hashable, string>(comparer);
var key = new Hashable(1, HashEquals);
dict[key] = "0";
var thread = new Thread(() => {
comparer.EqualWaiting.WaitOne();
dict.Remove(key);
dict[new Hashable(1, HashEquals)] = "1";
comparer.DictUpdated.Set();
});
thread.Start();
Assert.AreEqual("1", dict[new Hashable(1, HashEquals)]);
}
private void CreateSQLParameterArray(AnalysisDictionary values, out SqlParameter[] sqlParamArray)
{
// Period
var period = new AnalysisAttribute();
if (values.ContainsKey("Period"))
{
period = values["Period"];
}
// Start Date
var startDate = new AnalysisAttribute();
if (values.ContainsKey("StartDate"))
{
startDate = values["StartDate"];
}
// End Date
var endDate = new AnalysisAttribute();
if (values.ContainsKey("EndDate"))
{
endDate = values["EndDate"];
}
sqlParamArray = new[]
{
new SqlParameter("@Period", SqlDbType.Int)
{
Value = period.Value
},
new SqlParameter("@StartDate", SqlDbType.DateTime)
{
Value = startDate.Value
},
new SqlParameter("@EndDate", SqlDbType.DateTime)
{
Value = endDate.Value
}
};
}
public AnalysisDictionary Analyse(string connectionString, AnalysisDictionary values)
{
this.ConnectionString = connectionString;
var analysisResult = new AnalysisDictionary {
Name = "Shopping"
};
var period = Convert.ToInt32(values["Period"].Value);
var startDate = Convert.ToDateTime(values["StartDate"].Value);
var endDate = Convert.ToDateTime(values["EndDate"].Value);
var threshold = Convert.ToInt32(values["Threshold"].Value);
var costPerRequest = Convert.ToInt32(values["CostPerRequest"].Value);
var currencySymbol = Convert.ToString(values["CurrencySymbol"].Value);
analysisResult.Add("Period", new AnalysisAttribute {
Value = string.Format("{0:n0}", period)
});
analysisResult.Add("StartDate", new AnalysisAttribute {
Value = startDate.ToString("d-MMMM-yyyy")
});
analysisResult.Add("EndDate", new AnalysisAttribute {
Value = endDate.ToString("d-MMMM-yyyy")
});
analysisResult.Add("CurrencySymbol", new AnalysisAttribute {
Value = currencySymbol
});
analysisResult.Add("CostPerRequest", new AnalysisAttribute {
Value = string.Format("{0:n0}", costPerRequest)
});
var exclusionFilter = Exclusions.GetExclusionFilter(this.ConnectionString);
// Total number of requests
GetTotalNumberOfRequests(analysisResult, exclusionFilter, startDate, endDate, period, threshold, costPerRequest, currencySymbol);
// Top program list
var maximumNoOfProgramsToRetreive = Convert.ToInt32(values["MaximumNoOfProgramsToRetreive"].Value);
// This will be used later when the report supports it.
var ds = GetTopProgramList(exclusionFilter, startDate, endDate, maximumNoOfProgramsToRetreive, threshold);
return(analysisResult);
}
public void Enumeration()
{
var dict = new AnalysisDictionary <string, string>()
{
{ "1", "One" }
};
var enumer = dict.GetEnumerator();
while (enumer.MoveNext())
{
Assert.AreEqual("1", enumer.Current.Key);
}
var enumer2 = ((IEnumerable)dict).GetEnumerator();
while (enumer2.MoveNext())
{
Assert.AreEqual("1", ((KeyValuePair <string, string>)enumer2.Current).Key);
}
}
private List <SqlAnalysisQuery> GetQueries(AnalysisDictionary values)
{
var xmlDocument = XDocument.Parse(Resources.SavingsAnalysis_AnalysisEngine_Dummy);
var analysisQueries = new List <SqlAnalysisQuery>();
foreach (var query in xmlDocument.Descendants("query"))
{
var queryAttrib = query.Element("value");
var nameAttrib = query.Attribute("data");
if (queryAttrib != null && nameAttrib != null && !string.IsNullOrEmpty(queryAttrib.Value) && !string.IsNullOrEmpty(nameAttrib.Value))
{
analysisQueries.Add(new SqlAnalysisQuery(queryAttrib.Value, nameAttrib.Value, nameAttrib.Value));
if (values.ContainsKey(nameAttrib.Value) == false)
{
values.Add(nameAttrib.Value, new AnalysisAttribute());
}
}
}
return(analysisQueries);
}
private IEnumerable<SqlAnalysisQuery> GetQueries(AnalysisDictionary values)
{
XDocument xmlDocument = XDocument.Parse(Resources.SavingsAnalysis_NightWatchman_SQLQueries);
var analysisQueries = new List<SqlAnalysisQuery>();
foreach (XElement query in xmlDocument.Descendants("query"))
{
XElement queryAttrib = query.Element("value");
XAttribute nameAttrib = query.Attribute("data");
if (queryAttrib != null && nameAttrib != null && !string.IsNullOrEmpty(queryAttrib.Value)
&& !string.IsNullOrEmpty(nameAttrib.Value))
{
analysisQueries.Add(new SqlAnalysisQuery(queryAttrib.Value, nameAttrib.Value, nameAttrib.Value));
if (values.ContainsKey(nameAttrib.Value) == false)
{
values.Add(nameAttrib.Value, new AnalysisAttribute());
}
}
}
return analysisQueries;
}
public void Run(SqlConnection connection, SqlAnalysisQuery query, AnalysisDictionary dictionary, SqlParameter[] sqlParams)
{
using (var cmd = connection.CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = query.QueryText;
if (sqlParams != null)
{
cmd.Parameters.AddRange(sqlParams);
}
using (var reader = cmd.ExecuteReader())
{
if (!reader.HasRows || !reader.Read())
{
throw new InvalidOperationException("No data returned by query");
}
// Go through each defined statistic, read the value for that column and put it in our dictionary
var statsMap = query.StatisticNamesToColumnsMap;
foreach (var stat in statsMap)
{
var statisticKey = stat.Key; // We map the static name...
var columnName = stat.Value; // ... to the column to be read
var value = reader[columnName];
if (DBNull.Value.Equals(value))
{
dictionary[statisticKey].Value = string.Empty;
}
else
{
dictionary[statisticKey].Value = value.ToString();
}
}
}
}
}
public PieChart(AnalysisDictionary dataSource, List<string> keys, string imageFile)
: this()
{
if (dataSource == null)
{
throw new InvalidOperationException("Data source is invalid");
}
if (keys == null)
{
throw new InvalidOperationException("Graph keys are invalid");
}
if (string.IsNullOrWhiteSpace(imageFile))
{
throw new InvalidOperationException("Image path is invalid");
}
DataSource = dataSource;
Keys = keys;
ImageFile = imageFile;
}
public static void GeneratePieChartImage(AnalysisDictionary objchartdatasource, string path, List<string> keys, string chartimagepath)
{
var objChart = new PieChart(objchartdatasource, keys, chartimagepath);
objChart.GeneratePieChartImage();
}
internal void MakeUnionStronger() {
var cmp = KeyValues.Comparer as UnionComparer;
if (cmp != null && cmp.Strength == UnionComparer.MAX_STRENGTH) {
return;
}
if (cmp == null) {
cmp = UnionComparer.Instances[0];
} else {
cmp = UnionComparer.Instances[cmp.Strength + 1];
}
var matches = new Dictionary<AnalysisProxy, List<KeyValuePair<AnalysisProxy, IAnalysisSet>>>(cmp);
foreach (var keyValue in KeyValues) {
List<KeyValuePair<AnalysisProxy, IAnalysisSet>> values;
if (keyValue.Key.Value != null) {
if (!matches.TryGetValue(keyValue.Key, out values)) {
values = matches[keyValue.Key] = new List<KeyValuePair<AnalysisProxy, IAnalysisSet>>();
}
values.Add(keyValue);
}
}
KeyValues = new AnalysisDictionary<AnalysisProxy, IAnalysisSet>(cmp);
foreach (var list in matches.Values) {
bool dummy;
var key = list[0].Key;
var value = list[0].Value.AsUnion(cmp, out dummy);
foreach (var item in list.Skip(1)) {
key = cmp.MergeTypes(key, item.Key, out dummy);
value = value.Union(item.Value);
}
KeyValues[key] = value;
}
}
private void GetValuesFromProperty(object obj, AnalysisDictionary dictionaryUsedForAnalysis)
{
PropertyInfo[] properties = obj.GetType().GetProperties();
foreach (PropertyInfo property in properties)
{
object o = property.GetValue(obj, null);
var objAnalysisAttribute = new AnalysisAttribute { Value = Convert.ToString(o) };
dictionaryUsedForAnalysis.Add(property.Name, objAnalysisAttribute);
}
}
private void CreateSQLParameterArray(AnalysisDictionary values, out SqlParameter[] sqlParamArray)
{
// Period
var period = new AnalysisAttribute();
if (values.ContainsKey("Period"))
{
period = values["Period"];
}
// Start Date
var startDate = new AnalysisAttribute();
if (values.ContainsKey("StartDate"))
{
startDate = values["StartDate"];
}
// End Date
var endDate = new AnalysisAttribute();
if (values.ContainsKey("EndDate"))
{
endDate = values["EndDate"];
}
sqlParamArray = new[]
{
new SqlParameter("@Period", SqlDbType.Int) { Value = period.Value },
new SqlParameter("@StartDate", SqlDbType.DateTime) { Value = startDate.Value },
new SqlParameter("@EndDate", SqlDbType.DateTime) { Value = endDate.Value }
};
}
private void GetTotalNumberOfRequests(
AnalysisDictionary analysisResult,
string exclusionFilter,
DateTime startDate,
DateTime endDate,
int period,
int threshold,
int costPerRequest,
string currencySymbol)
{
try
{
using (var connection = new SqlConnection(this.ConnectionString))
{
connection.Open();
var command = new SqlCommand(GetTotalNumberOfRequestsSql(exclusionFilter), connection);
command.Parameters.Add("EndDate", SqlDbType.Date).Value = endDate.AddDays(1);
command.Parameters.Add("StartDate", SqlDbType.Date).Value = startDate;
command.Parameters.Add("Threshold", SqlDbType.Int).Value = threshold;
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
// Total Number Of One Off Requests
var totalNumberOfOneOffRequest = Convert.ToInt32(reader["TotalNumberOfOneOffRequest"]);
var analysisAttribute = new AnalysisAttribute
{
Value = string.Format("{0:n0}", totalNumberOfOneOffRequest)
};
analysisResult.Add("TotalNumberOfOneOffRequest", analysisAttribute);
// Total Number Of Requests
var totalNumberOfRequests = Convert.ToInt32(reader["TotalNumberOfRequests"]);
analysisAttribute = new AnalysisAttribute
{
Value = string.Format("{0:n0}", totalNumberOfRequests)
};
analysisResult.Add("TotalNumberOfRequests", analysisAttribute);
// Total Number Of Requests in a year
analysisAttribute = new AnalysisAttribute
{
Value = string.Format("{0:n0}", 365 * totalNumberOfRequests / period)
};
analysisResult.Add("TotalNumberOfRequestsInAYear", analysisAttribute);
// Total Number Of One Off Requests in a year
var totalNumberOfOneOffRequestInAYear = 365 * totalNumberOfOneOffRequest / period;
analysisAttribute = new AnalysisAttribute
{
Value = string.Format("{0:n0}", 365 * totalNumberOfOneOffRequest / period)
};
analysisResult.Add("TotalNumberOfOneOffRequestInAYear", analysisAttribute);
// Total Number Of One Off Requests Cost
analysisAttribute = new AnalysisAttribute
{
Value = string.Format("{0}{1:n0}", currencySymbol, totalNumberOfOneOffRequestInAYear * costPerRequest)
};
analysisResult.Add("TotalNumberOfOneOffRequestCost", analysisAttribute);
// Total Number Of One Off Requests in a year Cost
analysisAttribute = new AnalysisAttribute
{
Value = string.Format("{0}{1:n0}", currencySymbol, totalNumberOfOneOffRequest * costPerRequest)
};
analysisResult.Add("TotalNumberOfOneOffRequestInAYearCost", analysisAttribute);
}
reader.Close();
}
}
}
catch (Exception e)
{
// Need logging
throw new Exception("Could not get total number of requests", e);
}
}
private void RunQueries(
IEnumerable<SqlAnalysisQuery> queries, AnalysisDictionary analysisResult, AnalysisDictionary values)
{
using (var cnn = new SqlConnection(this.ConnectionString))
{
cnn.Open();
var runner = new SqlAnalysisQueryRunner();
foreach (SqlAnalysisQuery query in queries)
{
SqlParameter[] sqlParams;
this.CreateSQLParameterArray(values, out sqlParams);
runner.Run(cnn, query, analysisResult, sqlParams);
}
cnn.Close();
}
}
public DeclarativeEnvironmentRecord(Node ast, EnvironmentRecord outerScope)
: base(outerScope) {
_node = ast;
_variables = new AnalysisDictionary<string, VariableDef>();
}
