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(); } }
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 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>(); }